# Generated from GromacsPTParser.g4 by ANTLR 4.10.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,36,402,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
        6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,
        2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,
        7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,
        2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,
        7,33,2,34,7,34,2,35,7,35,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
        1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,5,0,91,8,0,10,0,12,0,94,9,0,1,0,
        1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,1,2,1,2,4,2,111,
        8,2,11,2,12,2,112,1,3,1,3,1,3,1,4,1,4,1,4,1,4,4,4,122,8,4,11,4,12,
        4,123,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,138,8,
        5,3,5,140,8,5,1,6,1,6,1,6,1,6,5,6,146,8,6,10,6,12,6,149,9,6,1,7,
        1,7,1,7,1,7,1,7,1,7,3,7,157,8,7,3,7,159,8,7,1,8,1,8,1,8,1,8,5,8,
        165,8,8,10,8,12,8,168,9,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3,
        9,179,8,9,1,10,1,10,1,10,1,10,5,10,185,8,10,10,10,12,10,188,9,10,
        1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,5,12,
        202,8,12,10,12,12,12,205,9,12,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
        1,13,1,13,1,13,1,13,3,13,218,8,13,3,13,220,8,13,3,13,222,8,13,1,
        14,1,14,1,14,1,14,5,14,228,8,14,10,14,12,14,231,9,14,1,15,1,15,1,
        15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,244,8,15,3,15,246,
        8,15,3,15,248,8,15,1,16,1,16,1,16,1,16,5,16,254,8,16,10,16,12,16,
        257,9,16,1,17,1,17,4,17,261,8,17,11,17,12,17,262,1,18,1,18,1,18,
        1,18,5,18,269,8,18,10,18,12,18,272,9,18,1,19,1,19,1,19,1,19,1,19,
        1,20,1,20,1,20,1,20,5,20,283,8,20,10,20,12,20,286,9,20,1,21,1,21,
        1,21,1,21,1,21,1,22,1,22,1,22,1,22,5,22,297,8,22,10,22,12,22,300,
        9,22,1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,5,24,310,8,24,10,24,
        12,24,313,9,24,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1,26,1,26,1,26,
        5,26,325,8,26,10,26,12,26,328,9,26,1,27,1,27,1,27,1,27,1,27,1,27,
        1,27,1,27,3,27,338,8,27,1,28,1,28,1,28,1,28,5,28,344,8,28,10,28,
        12,28,347,9,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        1,30,1,30,1,30,1,30,5,30,363,8,30,10,30,12,30,366,9,30,1,31,1,31,
        1,31,4,31,371,8,31,11,31,12,31,372,1,31,3,31,376,8,31,1,32,1,32,
        1,32,1,32,5,32,382,8,32,10,32,12,32,385,9,32,1,32,1,32,1,33,1,33,
        1,33,1,33,4,33,393,8,33,11,33,12,33,394,1,34,1,34,1,34,1,35,1,35,
        1,35,0,0,36,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,
        38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,0,1,1,0,21,22,
        415,0,92,1,0,0,0,2,97,1,0,0,0,4,106,1,0,0,0,6,114,1,0,0,0,8,117,
        1,0,0,0,10,125,1,0,0,0,12,141,1,0,0,0,14,150,1,0,0,0,16,160,1,0,
        0,0,18,169,1,0,0,0,20,180,1,0,0,0,22,189,1,0,0,0,24,197,1,0,0,0,
        26,206,1,0,0,0,28,223,1,0,0,0,30,232,1,0,0,0,32,249,1,0,0,0,34,258,
        1,0,0,0,36,264,1,0,0,0,38,273,1,0,0,0,40,278,1,0,0,0,42,287,1,0,
        0,0,44,292,1,0,0,0,46,301,1,0,0,0,48,305,1,0,0,0,50,314,1,0,0,0,
        52,320,1,0,0,0,54,329,1,0,0,0,56,339,1,0,0,0,58,348,1,0,0,0,60,358,
        1,0,0,0,62,367,1,0,0,0,64,377,1,0,0,0,66,388,1,0,0,0,68,396,1,0,
        0,0,70,399,1,0,0,0,72,91,3,2,1,0,73,91,3,4,2,0,74,91,3,8,4,0,75,
        91,3,12,6,0,76,91,3,16,8,0,77,91,3,20,10,0,78,91,3,24,12,0,79,91,
        3,28,14,0,80,91,3,32,16,0,81,91,3,36,18,0,82,91,3,40,20,0,83,91,
        3,44,22,0,84,91,3,48,24,0,85,91,3,52,26,0,86,91,3,56,28,0,87,91,
        3,60,30,0,88,91,3,64,32,0,89,91,3,66,33,0,90,72,1,0,0,0,90,73,1,
        0,0,0,90,74,1,0,0,0,90,75,1,0,0,0,90,76,1,0,0,0,90,77,1,0,0,0,90,
        78,1,0,0,0,90,79,1,0,0,0,90,80,1,0,0,0,90,81,1,0,0,0,90,82,1,0,0,
        0,90,83,1,0,0,0,90,84,1,0,0,0,90,85,1,0,0,0,90,86,1,0,0,0,90,87,
        1,0,0,0,90,88,1,0,0,0,90,89,1,0,0,0,91,94,1,0,0,0,92,90,1,0,0,0,
        92,93,1,0,0,0,93,95,1,0,0,0,94,92,1,0,0,0,95,96,5,0,0,1,96,1,1,0,
        0,0,97,98,5,1,0,0,98,99,5,3,0,0,99,100,5,2,0,0,100,101,5,21,0,0,
        101,102,5,21,0,0,102,103,5,26,0,0,103,104,5,22,0,0,104,105,5,22,
        0,0,105,3,1,0,0,0,106,107,5,1,0,0,107,108,5,4,0,0,108,110,5,2,0,
        0,109,111,3,6,3,0,110,109,1,0,0,0,111,112,1,0,0,0,112,110,1,0,0,
        0,112,113,1,0,0,0,113,5,1,0,0,0,114,115,5,26,0,0,115,116,5,21,0,
        0,116,7,1,0,0,0,117,118,5,1,0,0,118,119,5,5,0,0,119,121,5,2,0,0,
        120,122,3,10,5,0,121,120,1,0,0,0,122,123,1,0,0,0,123,121,1,0,0,0,
        123,124,1,0,0,0,124,9,1,0,0,0,125,126,5,21,0,0,126,127,5,26,0,0,
        127,128,5,21,0,0,128,129,5,26,0,0,129,130,5,26,0,0,130,131,5,21,
        0,0,131,139,3,70,35,0,132,137,3,70,35,0,133,134,5,26,0,0,134,135,
        3,70,35,0,135,136,3,70,35,0,136,138,1,0,0,0,137,133,1,0,0,0,137,
        138,1,0,0,0,138,140,1,0,0,0,139,132,1,0,0,0,139,140,1,0,0,0,140,
        11,1,0,0,0,141,142,5,1,0,0,142,143,5,6,0,0,143,147,5,2,0,0,144,146,
        3,14,7,0,145,144,1,0,0,0,146,149,1,0,0,0,147,145,1,0,0,0,147,148,
        1,0,0,0,148,13,1,0,0,0,149,147,1,0,0,0,150,151,5,21,0,0,151,152,
        5,21,0,0,152,158,5,21,0,0,153,154,3,70,35,0,154,156,3,70,35,0,155,
        157,3,70,35,0,156,155,1,0,0,0,156,157,1,0,0,0,157,159,1,0,0,0,158,
        153,1,0,0,0,158,159,1,0,0,0,159,15,1,0,0,0,160,161,5,1,0,0,161,162,
        5,7,0,0,162,166,5,2,0,0,163,165,3,18,9,0,164,163,1,0,0,0,165,168,
        1,0,0,0,166,164,1,0,0,0,166,167,1,0,0,0,167,17,1,0,0,0,168,166,1,
        0,0,0,169,170,5,21,0,0,170,171,5,21,0,0,171,172,5,21,0,0,172,173,
        3,70,35,0,173,178,3,70,35,0,174,175,3,70,35,0,175,176,3,70,35,0,
        176,177,3,70,35,0,177,179,1,0,0,0,178,174,1,0,0,0,178,179,1,0,0,
        0,179,19,1,0,0,0,180,181,5,1,0,0,181,182,5,8,0,0,182,186,5,2,0,0,
        183,185,3,22,11,0,184,183,1,0,0,0,185,188,1,0,0,0,186,184,1,0,0,
        0,186,187,1,0,0,0,187,21,1,0,0,0,188,186,1,0,0,0,189,190,5,21,0,
        0,190,191,5,21,0,0,191,192,5,21,0,0,192,193,3,70,35,0,193,194,3,
        70,35,0,194,195,3,70,35,0,195,196,3,70,35,0,196,23,1,0,0,0,197,198,
        5,1,0,0,198,199,5,9,0,0,199,203,5,2,0,0,200,202,3,26,13,0,201,200,
        1,0,0,0,202,205,1,0,0,0,203,201,1,0,0,0,203,204,1,0,0,0,204,25,1,
        0,0,0,205,203,1,0,0,0,206,207,5,21,0,0,207,208,5,21,0,0,208,209,
        5,21,0,0,209,210,5,21,0,0,210,211,3,70,35,0,211,221,3,70,35,0,212,
        219,3,70,35,0,213,217,3,70,35,0,214,215,3,70,35,0,215,216,3,70,35,
        0,216,218,1,0,0,0,217,214,1,0,0,0,217,218,1,0,0,0,218,220,1,0,0,
        0,219,213,1,0,0,0,219,220,1,0,0,0,220,222,1,0,0,0,221,212,1,0,0,
        0,221,222,1,0,0,0,222,27,1,0,0,0,223,224,5,1,0,0,224,225,5,10,0,
        0,225,229,5,2,0,0,226,228,3,30,15,0,227,226,1,0,0,0,228,231,1,0,
        0,0,229,227,1,0,0,0,229,230,1,0,0,0,230,29,1,0,0,0,231,229,1,0,0,
        0,232,233,5,21,0,0,233,234,5,21,0,0,234,235,5,21,0,0,235,236,5,21,
        0,0,236,237,5,21,0,0,237,238,3,70,35,0,238,247,3,70,35,0,239,245,
        3,70,35,0,240,241,3,70,35,0,241,243,3,70,35,0,242,244,3,70,35,0,
        243,242,1,0,0,0,243,244,1,0,0,0,244,246,1,0,0,0,245,240,1,0,0,0,
        245,246,1,0,0,0,246,248,1,0,0,0,247,239,1,0,0,0,247,248,1,0,0,0,
        248,31,1,0,0,0,249,250,5,1,0,0,250,251,5,11,0,0,251,255,5,2,0,0,
        252,254,3,34,17,0,253,252,1,0,0,0,254,257,1,0,0,0,255,253,1,0,0,
        0,255,256,1,0,0,0,256,33,1,0,0,0,257,255,1,0,0,0,258,260,5,21,0,
        0,259,261,5,21,0,0,260,259,1,0,0,0,261,262,1,0,0,0,262,260,1,0,0,
        0,262,263,1,0,0,0,263,35,1,0,0,0,264,265,5,1,0,0,265,266,5,12,0,
        0,266,270,5,2,0,0,267,269,3,38,19,0,268,267,1,0,0,0,269,272,1,0,
        0,0,270,268,1,0,0,0,270,271,1,0,0,0,271,37,1,0,0,0,272,270,1,0,0,
        0,273,274,5,21,0,0,274,275,5,21,0,0,275,276,5,21,0,0,276,277,3,70,
        35,0,277,39,1,0,0,0,278,279,5,1,0,0,279,280,5,13,0,0,280,284,5,2,
        0,0,281,283,3,42,21,0,282,281,1,0,0,0,283,286,1,0,0,0,284,282,1,
        0,0,0,284,285,1,0,0,0,285,41,1,0,0,0,286,284,1,0,0,0,287,288,5,21,
        0,0,288,289,5,21,0,0,289,290,3,70,35,0,290,291,3,70,35,0,291,43,
        1,0,0,0,292,293,5,1,0,0,293,294,5,14,0,0,294,298,5,2,0,0,295,297,
        3,46,23,0,296,295,1,0,0,0,297,300,1,0,0,0,298,296,1,0,0,0,298,299,
        1,0,0,0,299,45,1,0,0,0,300,298,1,0,0,0,301,302,5,21,0,0,302,303,
        5,21,0,0,303,304,5,21,0,0,304,47,1,0,0,0,305,306,5,1,0,0,306,307,
        5,15,0,0,307,311,5,2,0,0,308,310,3,50,25,0,309,308,1,0,0,0,310,313,
        1,0,0,0,311,309,1,0,0,0,311,312,1,0,0,0,312,49,1,0,0,0,313,311,1,
        0,0,0,314,315,5,21,0,0,315,316,5,21,0,0,316,317,5,21,0,0,317,318,
        5,21,0,0,318,319,3,70,35,0,319,51,1,0,0,0,320,321,5,1,0,0,321,322,
        5,16,0,0,322,326,5,2,0,0,323,325,3,54,27,0,324,323,1,0,0,0,325,328,
        1,0,0,0,326,324,1,0,0,0,326,327,1,0,0,0,327,53,1,0,0,0,328,326,1,
        0,0,0,329,330,5,21,0,0,330,331,5,21,0,0,331,332,5,21,0,0,332,333,
        5,21,0,0,333,334,5,21,0,0,334,335,3,70,35,0,335,337,3,70,35,0,336,
        338,3,70,35,0,337,336,1,0,0,0,337,338,1,0,0,0,338,55,1,0,0,0,339,
        340,5,1,0,0,340,341,5,17,0,0,341,345,5,2,0,0,342,344,3,58,29,0,343,
        342,1,0,0,0,344,347,1,0,0,0,345,343,1,0,0,0,345,346,1,0,0,0,346,
        57,1,0,0,0,347,345,1,0,0,0,348,349,5,21,0,0,349,350,5,21,0,0,350,
        351,5,21,0,0,351,352,5,21,0,0,352,353,5,21,0,0,353,354,5,21,0,0,
        354,355,3,70,35,0,355,356,3,70,35,0,356,357,3,70,35,0,357,59,1,0,
        0,0,358,359,5,1,0,0,359,360,5,18,0,0,360,364,5,2,0,0,361,363,3,62,
        31,0,362,361,1,0,0,0,363,366,1,0,0,0,364,362,1,0,0,0,364,365,1,0,
        0,0,365,61,1,0,0,0,366,364,1,0,0,0,367,368,5,21,0,0,368,370,5,21,
        0,0,369,371,5,21,0,0,370,369,1,0,0,0,371,372,1,0,0,0,372,370,1,0,
        0,0,372,373,1,0,0,0,373,375,1,0,0,0,374,376,3,70,35,0,375,374,1,
        0,0,0,375,376,1,0,0,0,376,63,1,0,0,0,377,378,5,1,0,0,378,379,5,19,
        0,0,379,383,5,31,0,0,380,382,5,34,0,0,381,380,1,0,0,0,382,385,1,
        0,0,0,383,381,1,0,0,0,383,384,1,0,0,0,384,386,1,0,0,0,385,383,1,
        0,0,0,386,387,5,36,0,0,387,65,1,0,0,0,388,389,5,1,0,0,389,390,5,
        20,0,0,390,392,5,2,0,0,391,393,3,68,34,0,392,391,1,0,0,0,393,394,
        1,0,0,0,394,392,1,0,0,0,394,395,1,0,0,0,395,67,1,0,0,0,396,397,5,
        26,0,0,397,398,5,21,0,0,398,69,1,0,0,0,399,400,7,0,0,0,400,71,1,
        0,0,0,34,90,92,112,123,137,139,147,156,158,166,178,186,203,217,219,
        221,229,243,245,247,255,262,270,284,298,311,326,337,345,364,372,
        375,383,394
    ]

class GromacsPTParser ( Parser ):

    grammarFileName = "GromacsPTParser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'['", "']'", "'default'", "'moleculetype'", 
                     "'atoms'", "'bonds'", "'pairs'", "'pairs_nb'", "'angles'", 
                     "'dihedrals'", "'exclusions'", "'constraints'", "'settles'", 
                     "'virtual_sites1'", "'virtual_sites2'", "'virtual_sites3'", 
                     "'virtual_sites4'", "'virtual_sitesn'", "'system'", 
                     "'molecules'" ]

    symbolicNames = [ "<INVALID>", "L_brkt", "R_brkt", "Default", "Moleculetype", 
                      "Atoms", "Bonds", "Pairs", "Pairs_nb", "Angles", "Dihedrals", 
                      "Exclusions", "Constraints", "Settles", "Virtual_sites1", 
                      "Virtual_sites2", "Virtual_sites3", "Virtual_sites4", 
                      "Virtual_sitesn", "System", "Molecules", "Integer", 
                      "Float", "SHARP_COMMENT", "EXCLM_COMMENT", "SMCLN_COMMENT", 
                      "Simple_name", "SPACE", "COMMENT", "SECTION_COMMENT", 
                      "LINE_COMMENT", "R_brkt_A", "SECTION_COMMENT_A", "LINE_COMMENT_A", 
                      "Simple_name_A", "SPACE_A", "RETURN_A" ]

    RULE_gromacs_pt = 0
    RULE_default_statement = 1
    RULE_moleculetype_statement = 2
    RULE_moleculetype = 3
    RULE_atoms_statement = 4
    RULE_atoms = 5
    RULE_bonds_statement = 6
    RULE_bonds = 7
    RULE_pairs_statement = 8
    RULE_pairs = 9
    RULE_pairs_nb_statement = 10
    RULE_pairs_nb = 11
    RULE_angles_statement = 12
    RULE_angles = 13
    RULE_dihedrals_statement = 14
    RULE_dihedrals = 15
    RULE_exclusions_statement = 16
    RULE_exclusions = 17
    RULE_constraints_statement = 18
    RULE_constraints = 19
    RULE_settles_statement = 20
    RULE_settles = 21
    RULE_virtual_sites1_statement = 22
    RULE_virtual_sites1 = 23
    RULE_virtual_sites2_statement = 24
    RULE_virtual_sites2 = 25
    RULE_virtual_sites3_statement = 26
    RULE_virtual_sites3 = 27
    RULE_virtual_sites4_statement = 28
    RULE_virtual_sites4 = 29
    RULE_virtual_sitesn_statement = 30
    RULE_virtual_sitesn = 31
    RULE_system_statement = 32
    RULE_molecules_statement = 33
    RULE_molecules = 34
    RULE_number = 35

    ruleNames =  [ "gromacs_pt", "default_statement", "moleculetype_statement", 
                   "moleculetype", "atoms_statement", "atoms", "bonds_statement", 
                   "bonds", "pairs_statement", "pairs", "pairs_nb_statement", 
                   "pairs_nb", "angles_statement", "angles", "dihedrals_statement", 
                   "dihedrals", "exclusions_statement", "exclusions", "constraints_statement", 
                   "constraints", "settles_statement", "settles", "virtual_sites1_statement", 
                   "virtual_sites1", "virtual_sites2_statement", "virtual_sites2", 
                   "virtual_sites3_statement", "virtual_sites3", "virtual_sites4_statement", 
                   "virtual_sites4", "virtual_sitesn_statement", "virtual_sitesn", 
                   "system_statement", "molecules_statement", "molecules", 
                   "number" ]

    EOF = Token.EOF
    L_brkt=1
    R_brkt=2
    Default=3
    Moleculetype=4
    Atoms=5
    Bonds=6
    Pairs=7
    Pairs_nb=8
    Angles=9
    Dihedrals=10
    Exclusions=11
    Constraints=12
    Settles=13
    Virtual_sites1=14
    Virtual_sites2=15
    Virtual_sites3=16
    Virtual_sites4=17
    Virtual_sitesn=18
    System=19
    Molecules=20
    Integer=21
    Float=22
    SHARP_COMMENT=23
    EXCLM_COMMENT=24
    SMCLN_COMMENT=25
    Simple_name=26
    SPACE=27
    COMMENT=28
    SECTION_COMMENT=29
    LINE_COMMENT=30
    R_brkt_A=31
    SECTION_COMMENT_A=32
    LINE_COMMENT_A=33
    Simple_name_A=34
    SPACE_A=35
    RETURN_A=36

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.10.1")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class Gromacs_ptContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(GromacsPTParser.EOF, 0)

        def default_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Default_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Default_statementContext,i)


        def moleculetype_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Moleculetype_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Moleculetype_statementContext,i)


        def atoms_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Atoms_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Atoms_statementContext,i)


        def bonds_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Bonds_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Bonds_statementContext,i)


        def pairs_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Pairs_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Pairs_statementContext,i)


        def pairs_nb_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Pairs_nb_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Pairs_nb_statementContext,i)


        def angles_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Angles_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Angles_statementContext,i)


        def dihedrals_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Dihedrals_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Dihedrals_statementContext,i)


        def exclusions_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Exclusions_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Exclusions_statementContext,i)


        def constraints_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Constraints_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Constraints_statementContext,i)


        def settles_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Settles_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Settles_statementContext,i)


        def virtual_sites1_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites1_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites1_statementContext,i)


        def virtual_sites2_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites2_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites2_statementContext,i)


        def virtual_sites3_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites3_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites3_statementContext,i)


        def virtual_sites4_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites4_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites4_statementContext,i)


        def virtual_sitesn_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sitesn_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sitesn_statementContext,i)


        def system_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.System_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.System_statementContext,i)


        def molecules_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Molecules_statementContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Molecules_statementContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_gromacs_pt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGromacs_pt" ):
                listener.enterGromacs_pt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGromacs_pt" ):
                listener.exitGromacs_pt(self)




    def gromacs_pt(self):

        localctx = GromacsPTParser.Gromacs_ptContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_gromacs_pt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 92
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.L_brkt:
                self.state = 90
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 72
                    self.default_statement()
                    pass

                elif la_ == 2:
                    self.state = 73
                    self.moleculetype_statement()
                    pass

                elif la_ == 3:
                    self.state = 74
                    self.atoms_statement()
                    pass

                elif la_ == 4:
                    self.state = 75
                    self.bonds_statement()
                    pass

                elif la_ == 5:
                    self.state = 76
                    self.pairs_statement()
                    pass

                elif la_ == 6:
                    self.state = 77
                    self.pairs_nb_statement()
                    pass

                elif la_ == 7:
                    self.state = 78
                    self.angles_statement()
                    pass

                elif la_ == 8:
                    self.state = 79
                    self.dihedrals_statement()
                    pass

                elif la_ == 9:
                    self.state = 80
                    self.exclusions_statement()
                    pass

                elif la_ == 10:
                    self.state = 81
                    self.constraints_statement()
                    pass

                elif la_ == 11:
                    self.state = 82
                    self.settles_statement()
                    pass

                elif la_ == 12:
                    self.state = 83
                    self.virtual_sites1_statement()
                    pass

                elif la_ == 13:
                    self.state = 84
                    self.virtual_sites2_statement()
                    pass

                elif la_ == 14:
                    self.state = 85
                    self.virtual_sites3_statement()
                    pass

                elif la_ == 15:
                    self.state = 86
                    self.virtual_sites4_statement()
                    pass

                elif la_ == 16:
                    self.state = 87
                    self.virtual_sitesn_statement()
                    pass

                elif la_ == 17:
                    self.state = 88
                    self.system_statement()
                    pass

                elif la_ == 18:
                    self.state = 89
                    self.molecules_statement()
                    pass


                self.state = 94
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 95
            self.match(GromacsPTParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Default_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Default(self):
            return self.getToken(GromacsPTParser.Default, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def Simple_name(self):
            return self.getToken(GromacsPTParser.Simple_name, 0)

        def Float(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Float)
            else:
                return self.getToken(GromacsPTParser.Float, i)

        def getRuleIndex(self):
            return GromacsPTParser.RULE_default_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefault_statement" ):
                listener.enterDefault_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefault_statement" ):
                listener.exitDefault_statement(self)




    def default_statement(self):

        localctx = GromacsPTParser.Default_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_default_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 97
            self.match(GromacsPTParser.L_brkt)
            self.state = 98
            self.match(GromacsPTParser.Default)
            self.state = 99
            self.match(GromacsPTParser.R_brkt)
            self.state = 100
            self.match(GromacsPTParser.Integer)
            self.state = 101
            self.match(GromacsPTParser.Integer)
            self.state = 102
            self.match(GromacsPTParser.Simple_name)
            self.state = 103
            self.match(GromacsPTParser.Float)
            self.state = 104
            self.match(GromacsPTParser.Float)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Moleculetype_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Moleculetype(self):
            return self.getToken(GromacsPTParser.Moleculetype, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def moleculetype(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.MoleculetypeContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.MoleculetypeContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_moleculetype_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMoleculetype_statement" ):
                listener.enterMoleculetype_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMoleculetype_statement" ):
                listener.exitMoleculetype_statement(self)




    def moleculetype_statement(self):

        localctx = GromacsPTParser.Moleculetype_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_moleculetype_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 106
            self.match(GromacsPTParser.L_brkt)
            self.state = 107
            self.match(GromacsPTParser.Moleculetype)
            self.state = 108
            self.match(GromacsPTParser.R_brkt)
            self.state = 110 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 109
                self.moleculetype()
                self.state = 112 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GromacsPTParser.Simple_name):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MoleculetypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Simple_name(self):
            return self.getToken(GromacsPTParser.Simple_name, 0)

        def Integer(self):
            return self.getToken(GromacsPTParser.Integer, 0)

        def getRuleIndex(self):
            return GromacsPTParser.RULE_moleculetype

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMoleculetype" ):
                listener.enterMoleculetype(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMoleculetype" ):
                listener.exitMoleculetype(self)




    def moleculetype(self):

        localctx = GromacsPTParser.MoleculetypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_moleculetype)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 114
            self.match(GromacsPTParser.Simple_name)
            self.state = 115
            self.match(GromacsPTParser.Integer)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Atoms_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Atoms(self):
            return self.getToken(GromacsPTParser.Atoms, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def atoms(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.AtomsContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.AtomsContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_atoms_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAtoms_statement" ):
                listener.enterAtoms_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAtoms_statement" ):
                listener.exitAtoms_statement(self)




    def atoms_statement(self):

        localctx = GromacsPTParser.Atoms_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_atoms_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 117
            self.match(GromacsPTParser.L_brkt)
            self.state = 118
            self.match(GromacsPTParser.Atoms)
            self.state = 119
            self.match(GromacsPTParser.R_brkt)
            self.state = 121 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 120
                self.atoms()
                self.state = 123 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GromacsPTParser.Integer):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtomsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def Simple_name(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Simple_name)
            else:
                return self.getToken(GromacsPTParser.Simple_name, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_atoms

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAtoms" ):
                listener.enterAtoms(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAtoms" ):
                listener.exitAtoms(self)




    def atoms(self):

        localctx = GromacsPTParser.AtomsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_atoms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 125
            self.match(GromacsPTParser.Integer)
            self.state = 126
            self.match(GromacsPTParser.Simple_name)
            self.state = 127
            self.match(GromacsPTParser.Integer)
            self.state = 128
            self.match(GromacsPTParser.Simple_name)
            self.state = 129
            self.match(GromacsPTParser.Simple_name)
            self.state = 130
            self.match(GromacsPTParser.Integer)
            self.state = 131
            self.number()
            self.state = 139
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.state = 132
                self.number()
                self.state = 137
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==GromacsPTParser.Simple_name:
                    self.state = 133
                    self.match(GromacsPTParser.Simple_name)
                    self.state = 134
                    self.number()
                    self.state = 135
                    self.number()




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Bonds_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Bonds(self):
            return self.getToken(GromacsPTParser.Bonds, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def bonds(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.BondsContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.BondsContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_bonds_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBonds_statement" ):
                listener.enterBonds_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBonds_statement" ):
                listener.exitBonds_statement(self)




    def bonds_statement(self):

        localctx = GromacsPTParser.Bonds_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_bonds_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 141
            self.match(GromacsPTParser.L_brkt)
            self.state = 142
            self.match(GromacsPTParser.Bonds)
            self.state = 143
            self.match(GromacsPTParser.R_brkt)
            self.state = 147
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 144
                self.bonds()
                self.state = 149
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BondsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_bonds

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBonds" ):
                listener.enterBonds(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBonds" ):
                listener.exitBonds(self)




    def bonds(self):

        localctx = GromacsPTParser.BondsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_bonds)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 150
            self.match(GromacsPTParser.Integer)
            self.state = 151
            self.match(GromacsPTParser.Integer)
            self.state = 152
            self.match(GromacsPTParser.Integer)
            self.state = 158
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 153
                self.number()
                self.state = 154
                self.number()
                self.state = 156
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
                if la_ == 1:
                    self.state = 155
                    self.number()




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pairs_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Pairs(self):
            return self.getToken(GromacsPTParser.Pairs, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def pairs(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.PairsContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.PairsContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_pairs_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPairs_statement" ):
                listener.enterPairs_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPairs_statement" ):
                listener.exitPairs_statement(self)




    def pairs_statement(self):

        localctx = GromacsPTParser.Pairs_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_pairs_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 160
            self.match(GromacsPTParser.L_brkt)
            self.state = 161
            self.match(GromacsPTParser.Pairs)
            self.state = 162
            self.match(GromacsPTParser.R_brkt)
            self.state = 166
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 163
                self.pairs()
                self.state = 168
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PairsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_pairs

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPairs" ):
                listener.enterPairs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPairs" ):
                listener.exitPairs(self)




    def pairs(self):

        localctx = GromacsPTParser.PairsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_pairs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 169
            self.match(GromacsPTParser.Integer)
            self.state = 170
            self.match(GromacsPTParser.Integer)
            self.state = 171
            self.match(GromacsPTParser.Integer)
            self.state = 172
            self.number()
            self.state = 173
            self.number()
            self.state = 178
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.state = 174
                self.number()
                self.state = 175
                self.number()
                self.state = 176
                self.number()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pairs_nb_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Pairs_nb(self):
            return self.getToken(GromacsPTParser.Pairs_nb, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def pairs_nb(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Pairs_nbContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Pairs_nbContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_pairs_nb_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPairs_nb_statement" ):
                listener.enterPairs_nb_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPairs_nb_statement" ):
                listener.exitPairs_nb_statement(self)




    def pairs_nb_statement(self):

        localctx = GromacsPTParser.Pairs_nb_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_pairs_nb_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 180
            self.match(GromacsPTParser.L_brkt)
            self.state = 181
            self.match(GromacsPTParser.Pairs_nb)
            self.state = 182
            self.match(GromacsPTParser.R_brkt)
            self.state = 186
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 183
                self.pairs_nb()
                self.state = 188
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pairs_nbContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_pairs_nb

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPairs_nb" ):
                listener.enterPairs_nb(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPairs_nb" ):
                listener.exitPairs_nb(self)




    def pairs_nb(self):

        localctx = GromacsPTParser.Pairs_nbContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_pairs_nb)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 189
            self.match(GromacsPTParser.Integer)
            self.state = 190
            self.match(GromacsPTParser.Integer)
            self.state = 191
            self.match(GromacsPTParser.Integer)
            self.state = 192
            self.number()
            self.state = 193
            self.number()
            self.state = 194
            self.number()
            self.state = 195
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angles_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Angles(self):
            return self.getToken(GromacsPTParser.Angles, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def angles(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.AnglesContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.AnglesContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_angles_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAngles_statement" ):
                listener.enterAngles_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAngles_statement" ):
                listener.exitAngles_statement(self)




    def angles_statement(self):

        localctx = GromacsPTParser.Angles_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_angles_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 197
            self.match(GromacsPTParser.L_brkt)
            self.state = 198
            self.match(GromacsPTParser.Angles)
            self.state = 199
            self.match(GromacsPTParser.R_brkt)
            self.state = 203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 200
                self.angles()
                self.state = 205
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnglesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_angles

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAngles" ):
                listener.enterAngles(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAngles" ):
                listener.exitAngles(self)




    def angles(self):

        localctx = GromacsPTParser.AnglesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_angles)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 206
            self.match(GromacsPTParser.Integer)
            self.state = 207
            self.match(GromacsPTParser.Integer)
            self.state = 208
            self.match(GromacsPTParser.Integer)
            self.state = 209
            self.match(GromacsPTParser.Integer)
            self.state = 210
            self.number()
            self.state = 211
            self.number()
            self.state = 221
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.state = 212
                self.number()
                self.state = 219
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                if la_ == 1:
                    self.state = 213
                    self.number()
                    self.state = 217
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
                    if la_ == 1:
                        self.state = 214
                        self.number()
                        self.state = 215
                        self.number()






        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedrals_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Dihedrals(self):
            return self.getToken(GromacsPTParser.Dihedrals, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def dihedrals(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.DihedralsContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.DihedralsContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_dihedrals_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDihedrals_statement" ):
                listener.enterDihedrals_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDihedrals_statement" ):
                listener.exitDihedrals_statement(self)




    def dihedrals_statement(self):

        localctx = GromacsPTParser.Dihedrals_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_dihedrals_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 223
            self.match(GromacsPTParser.L_brkt)
            self.state = 224
            self.match(GromacsPTParser.Dihedrals)
            self.state = 225
            self.match(GromacsPTParser.R_brkt)
            self.state = 229
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 226
                self.dihedrals()
                self.state = 231
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DihedralsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_dihedrals

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDihedrals" ):
                listener.enterDihedrals(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDihedrals" ):
                listener.exitDihedrals(self)




    def dihedrals(self):

        localctx = GromacsPTParser.DihedralsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_dihedrals)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(GromacsPTParser.Integer)
            self.state = 233
            self.match(GromacsPTParser.Integer)
            self.state = 234
            self.match(GromacsPTParser.Integer)
            self.state = 235
            self.match(GromacsPTParser.Integer)
            self.state = 236
            self.match(GromacsPTParser.Integer)
            self.state = 237
            self.number()
            self.state = 238
            self.number()
            self.state = 247
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.state = 239
                self.number()
                self.state = 245
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 240
                    self.number()
                    self.state = 241
                    self.number()
                    self.state = 243
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
                    if la_ == 1:
                        self.state = 242
                        self.number()






        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Exclusions_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Exclusions(self):
            return self.getToken(GromacsPTParser.Exclusions, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def exclusions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.ExclusionsContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.ExclusionsContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_exclusions_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExclusions_statement" ):
                listener.enterExclusions_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExclusions_statement" ):
                listener.exitExclusions_statement(self)




    def exclusions_statement(self):

        localctx = GromacsPTParser.Exclusions_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_exclusions_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 249
            self.match(GromacsPTParser.L_brkt)
            self.state = 250
            self.match(GromacsPTParser.Exclusions)
            self.state = 251
            self.match(GromacsPTParser.R_brkt)
            self.state = 255
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 252
                self.exclusions()
                self.state = 257
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExclusionsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def getRuleIndex(self):
            return GromacsPTParser.RULE_exclusions

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExclusions" ):
                listener.enterExclusions(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExclusions" ):
                listener.exitExclusions(self)




    def exclusions(self):

        localctx = GromacsPTParser.ExclusionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_exclusions)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 258
            self.match(GromacsPTParser.Integer)
            self.state = 260 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 259
                    self.match(GromacsPTParser.Integer)

                else:
                    raise NoViableAltException(self)
                self.state = 262 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,21,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constraints_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Constraints(self):
            return self.getToken(GromacsPTParser.Constraints, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def constraints(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.ConstraintsContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.ConstraintsContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_constraints_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstraints_statement" ):
                listener.enterConstraints_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstraints_statement" ):
                listener.exitConstraints_statement(self)




    def constraints_statement(self):

        localctx = GromacsPTParser.Constraints_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_constraints_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 264
            self.match(GromacsPTParser.L_brkt)
            self.state = 265
            self.match(GromacsPTParser.Constraints)
            self.state = 266
            self.match(GromacsPTParser.R_brkt)
            self.state = 270
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 267
                self.constraints()
                self.state = 272
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstraintsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self):
            return self.getTypedRuleContext(GromacsPTParser.NumberContext,0)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_constraints

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstraints" ):
                listener.enterConstraints(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstraints" ):
                listener.exitConstraints(self)




    def constraints(self):

        localctx = GromacsPTParser.ConstraintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_constraints)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 273
            self.match(GromacsPTParser.Integer)
            self.state = 274
            self.match(GromacsPTParser.Integer)
            self.state = 275
            self.match(GromacsPTParser.Integer)
            self.state = 276
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Settles_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Settles(self):
            return self.getToken(GromacsPTParser.Settles, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def settles(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.SettlesContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.SettlesContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_settles_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSettles_statement" ):
                listener.enterSettles_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSettles_statement" ):
                listener.exitSettles_statement(self)




    def settles_statement(self):

        localctx = GromacsPTParser.Settles_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_settles_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 278
            self.match(GromacsPTParser.L_brkt)
            self.state = 279
            self.match(GromacsPTParser.Settles)
            self.state = 280
            self.match(GromacsPTParser.R_brkt)
            self.state = 284
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 281
                self.settles()
                self.state = 286
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SettlesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_settles

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSettles" ):
                listener.enterSettles(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSettles" ):
                listener.exitSettles(self)




    def settles(self):

        localctx = GromacsPTParser.SettlesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_settles)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 287
            self.match(GromacsPTParser.Integer)
            self.state = 288
            self.match(GromacsPTParser.Integer)
            self.state = 289
            self.number()
            self.state = 290
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites1_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Virtual_sites1(self):
            return self.getToken(GromacsPTParser.Virtual_sites1, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def virtual_sites1(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites1Context)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites1Context,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites1_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites1_statement" ):
                listener.enterVirtual_sites1_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites1_statement" ):
                listener.exitVirtual_sites1_statement(self)




    def virtual_sites1_statement(self):

        localctx = GromacsPTParser.Virtual_sites1_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_virtual_sites1_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 292
            self.match(GromacsPTParser.L_brkt)
            self.state = 293
            self.match(GromacsPTParser.Virtual_sites1)
            self.state = 294
            self.match(GromacsPTParser.R_brkt)
            self.state = 298
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 295
                self.virtual_sites1()
                self.state = 300
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites1Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites1

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites1" ):
                listener.enterVirtual_sites1(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites1" ):
                listener.exitVirtual_sites1(self)




    def virtual_sites1(self):

        localctx = GromacsPTParser.Virtual_sites1Context(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_virtual_sites1)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 301
            self.match(GromacsPTParser.Integer)
            self.state = 302
            self.match(GromacsPTParser.Integer)
            self.state = 303
            self.match(GromacsPTParser.Integer)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites2_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Virtual_sites2(self):
            return self.getToken(GromacsPTParser.Virtual_sites2, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def virtual_sites2(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites2Context)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites2Context,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites2_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites2_statement" ):
                listener.enterVirtual_sites2_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites2_statement" ):
                listener.exitVirtual_sites2_statement(self)




    def virtual_sites2_statement(self):

        localctx = GromacsPTParser.Virtual_sites2_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_virtual_sites2_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 305
            self.match(GromacsPTParser.L_brkt)
            self.state = 306
            self.match(GromacsPTParser.Virtual_sites2)
            self.state = 307
            self.match(GromacsPTParser.R_brkt)
            self.state = 311
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 308
                self.virtual_sites2()
                self.state = 313
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites2Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self):
            return self.getTypedRuleContext(GromacsPTParser.NumberContext,0)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites2

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites2" ):
                listener.enterVirtual_sites2(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites2" ):
                listener.exitVirtual_sites2(self)




    def virtual_sites2(self):

        localctx = GromacsPTParser.Virtual_sites2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_virtual_sites2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 314
            self.match(GromacsPTParser.Integer)
            self.state = 315
            self.match(GromacsPTParser.Integer)
            self.state = 316
            self.match(GromacsPTParser.Integer)
            self.state = 317
            self.match(GromacsPTParser.Integer)
            self.state = 318
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites3_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Virtual_sites3(self):
            return self.getToken(GromacsPTParser.Virtual_sites3, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def virtual_sites3(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites3Context)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites3Context,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites3_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites3_statement" ):
                listener.enterVirtual_sites3_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites3_statement" ):
                listener.exitVirtual_sites3_statement(self)




    def virtual_sites3_statement(self):

        localctx = GromacsPTParser.Virtual_sites3_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_virtual_sites3_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 320
            self.match(GromacsPTParser.L_brkt)
            self.state = 321
            self.match(GromacsPTParser.Virtual_sites3)
            self.state = 322
            self.match(GromacsPTParser.R_brkt)
            self.state = 326
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 323
                self.virtual_sites3()
                self.state = 328
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites3Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites3

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites3" ):
                listener.enterVirtual_sites3(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites3" ):
                listener.exitVirtual_sites3(self)




    def virtual_sites3(self):

        localctx = GromacsPTParser.Virtual_sites3Context(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_virtual_sites3)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 329
            self.match(GromacsPTParser.Integer)
            self.state = 330
            self.match(GromacsPTParser.Integer)
            self.state = 331
            self.match(GromacsPTParser.Integer)
            self.state = 332
            self.match(GromacsPTParser.Integer)
            self.state = 333
            self.match(GromacsPTParser.Integer)
            self.state = 334
            self.number()
            self.state = 335
            self.number()
            self.state = 337
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 336
                self.number()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites4_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Virtual_sites4(self):
            return self.getToken(GromacsPTParser.Virtual_sites4, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def virtual_sites4(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sites4Context)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sites4Context,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites4_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites4_statement" ):
                listener.enterVirtual_sites4_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites4_statement" ):
                listener.exitVirtual_sites4_statement(self)




    def virtual_sites4_statement(self):

        localctx = GromacsPTParser.Virtual_sites4_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_virtual_sites4_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self.match(GromacsPTParser.L_brkt)
            self.state = 340
            self.match(GromacsPTParser.Virtual_sites4)
            self.state = 341
            self.match(GromacsPTParser.R_brkt)
            self.state = 345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 342
                self.virtual_sites4()
                self.state = 347
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sites4Context(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.NumberContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.NumberContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sites4

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sites4" ):
                listener.enterVirtual_sites4(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sites4" ):
                listener.exitVirtual_sites4(self)




    def virtual_sites4(self):

        localctx = GromacsPTParser.Virtual_sites4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_virtual_sites4)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 348
            self.match(GromacsPTParser.Integer)
            self.state = 349
            self.match(GromacsPTParser.Integer)
            self.state = 350
            self.match(GromacsPTParser.Integer)
            self.state = 351
            self.match(GromacsPTParser.Integer)
            self.state = 352
            self.match(GromacsPTParser.Integer)
            self.state = 353
            self.match(GromacsPTParser.Integer)
            self.state = 354
            self.number()
            self.state = 355
            self.number()
            self.state = 356
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sitesn_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Virtual_sitesn(self):
            return self.getToken(GromacsPTParser.Virtual_sitesn, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def virtual_sitesn(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.Virtual_sitesnContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.Virtual_sitesnContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sitesn_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sitesn_statement" ):
                listener.enterVirtual_sitesn_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sitesn_statement" ):
                listener.exitVirtual_sitesn_statement(self)




    def virtual_sitesn_statement(self):

        localctx = GromacsPTParser.Virtual_sitesn_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_virtual_sitesn_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 358
            self.match(GromacsPTParser.L_brkt)
            self.state = 359
            self.match(GromacsPTParser.Virtual_sitesn)
            self.state = 360
            self.match(GromacsPTParser.R_brkt)
            self.state = 364
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Integer:
                self.state = 361
                self.virtual_sitesn()
                self.state = 366
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Virtual_sitesnContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Integer)
            else:
                return self.getToken(GromacsPTParser.Integer, i)

        def number(self):
            return self.getTypedRuleContext(GromacsPTParser.NumberContext,0)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_virtual_sitesn

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtual_sitesn" ):
                listener.enterVirtual_sitesn(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtual_sitesn" ):
                listener.exitVirtual_sitesn(self)




    def virtual_sitesn(self):

        localctx = GromacsPTParser.Virtual_sitesnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_virtual_sitesn)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 367
            self.match(GromacsPTParser.Integer)
            self.state = 368
            self.match(GromacsPTParser.Integer)
            self.state = 370 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 369
                    self.match(GromacsPTParser.Integer)

                else:
                    raise NoViableAltException(self)
                self.state = 372 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,30,self._ctx)

            self.state = 375
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.state = 374
                self.number()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class System_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def System(self):
            return self.getToken(GromacsPTParser.System, 0)

        def R_brkt_A(self):
            return self.getToken(GromacsPTParser.R_brkt_A, 0)

        def RETURN_A(self):
            return self.getToken(GromacsPTParser.RETURN_A, 0)

        def Simple_name_A(self, i:int=None):
            if i is None:
                return self.getTokens(GromacsPTParser.Simple_name_A)
            else:
                return self.getToken(GromacsPTParser.Simple_name_A, i)

        def getRuleIndex(self):
            return GromacsPTParser.RULE_system_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSystem_statement" ):
                listener.enterSystem_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSystem_statement" ):
                listener.exitSystem_statement(self)




    def system_statement(self):

        localctx = GromacsPTParser.System_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_system_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 377
            self.match(GromacsPTParser.L_brkt)
            self.state = 378
            self.match(GromacsPTParser.System)
            self.state = 379
            self.match(GromacsPTParser.R_brkt_A)
            self.state = 383
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==GromacsPTParser.Simple_name_A:
                self.state = 380
                self.match(GromacsPTParser.Simple_name_A)
                self.state = 385
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 386
            self.match(GromacsPTParser.RETURN_A)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Molecules_statementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_brkt(self):
            return self.getToken(GromacsPTParser.L_brkt, 0)

        def Molecules(self):
            return self.getToken(GromacsPTParser.Molecules, 0)

        def R_brkt(self):
            return self.getToken(GromacsPTParser.R_brkt, 0)

        def molecules(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(GromacsPTParser.MoleculesContext)
            else:
                return self.getTypedRuleContext(GromacsPTParser.MoleculesContext,i)


        def getRuleIndex(self):
            return GromacsPTParser.RULE_molecules_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMolecules_statement" ):
                listener.enterMolecules_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMolecules_statement" ):
                listener.exitMolecules_statement(self)




    def molecules_statement(self):

        localctx = GromacsPTParser.Molecules_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_molecules_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 388
            self.match(GromacsPTParser.L_brkt)
            self.state = 389
            self.match(GromacsPTParser.Molecules)
            self.state = 390
            self.match(GromacsPTParser.R_brkt)
            self.state = 392 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 391
                self.molecules()
                self.state = 394 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==GromacsPTParser.Simple_name):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MoleculesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Simple_name(self):
            return self.getToken(GromacsPTParser.Simple_name, 0)

        def Integer(self):
            return self.getToken(GromacsPTParser.Integer, 0)

        def getRuleIndex(self):
            return GromacsPTParser.RULE_molecules

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMolecules" ):
                listener.enterMolecules(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMolecules" ):
                listener.exitMolecules(self)




    def molecules(self):

        localctx = GromacsPTParser.MoleculesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_molecules)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 396
            self.match(GromacsPTParser.Simple_name)
            self.state = 397
            self.match(GromacsPTParser.Integer)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Float(self):
            return self.getToken(GromacsPTParser.Float, 0)

        def Integer(self):
            return self.getToken(GromacsPTParser.Integer, 0)

        def getRuleIndex(self):
            return GromacsPTParser.RULE_number

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber" ):
                listener.enterNumber(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber" ):
                listener.exitNumber(self)




    def number(self):

        localctx = GromacsPTParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            _la = self._input.LA(1)
            if not(_la==GromacsPTParser.Integer or _la==GromacsPTParser.Float):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





