C1dInvGaConfParser.cpp

Go to the documentation of this file.

/* $ANTLR 2.7.6 (20070220): "C1dInvGaConf.g" -> "C1dInvGaConfParser.cpp"$ */
#include "C1dInvGaConfParser.hpp"
#include <antlr/NoViableAltException.hpp>
#include <antlr/SemanticException.hpp>
#include <antlr/ASTFactory.hpp>
#line 1 "C1dInvGaConf.g"
#line 8 "C1dInvGaConfParser.cpp"
C1dInvGaConfParser::C1dInvGaConfParser(antlr::TokenBuffer& tokenBuf, int k)
: antlr::LLkParser(tokenBuf,k)
{
}

C1dInvGaConfParser::C1dInvGaConfParser(antlr::TokenBuffer& tokenBuf)
: antlr::LLkParser(tokenBuf,10)
{
}

C1dInvGaConfParser::C1dInvGaConfParser(antlr::TokenStream& lexer, int k)
: antlr::LLkParser(lexer,k)
{
}

C1dInvGaConfParser::C1dInvGaConfParser(antlr::TokenStream& lexer)
: antlr::LLkParser(lexer,10)
{
}

C1dInvGaConfParser::C1dInvGaConfParser(const antlr::ParserSharedInputState& state)
: antlr::LLkParser(state,10)
{
}

void C1dInvGaConfParser::configentry() {
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                case VERBOSET:
                {
                        match(VERBOSET);
                        match(EQUAL);
                        verbose=boolvalue();
                        break;
                }
                case USEVREFMODELT:
                {
                        match(USEVREFMODELT);
                        match(EQUAL);
                        usevrefmodel=boolvalue();
                        break;
                }
                case VREFMODELT:
                {
                        match(VREFMODELT);
                        match(EQUAL);
                        vrefmodel=stringvalue();
                        break;
                }
                case MTFITEXPONENTT:
                {
                        match(MTFITEXPONENTT);
                        match(EQUAL);
                        mtfitexponent=numvalue();
                        break;
                }
                case RECFITEXPONENTT:
                {
                        match(RECFITEXPONENTT);
                        match(EQUAL);
                        recfitexponent=numvalue();
                        break;
                }
                case POPSIZET:
                {
                        match(POPSIZET);
                        match(EQUAL);
                        popsize=numvalue();
                        break;
                }
                case INITTEMPT:
                {
                        match(INITTEMPT);
                        match(EQUAL);
                        inittemp=numvalue();
                        break;
                }
                case COOLINGRATIOT:
                {
                        match(COOLINGRATIOT);
                        match(EQUAL);
                        coolingratio=numvalue();
                        break;
                }
                case GENERATIONST:
                {
                        match(GENERATIONST);
                        match(EQUAL);
                        generations=numvalue();
                        break;
                }
                case MUTATIONPROBT:
                {
                        match(MUTATIONPROBT);
                        match(EQUAL);
                        mutationprob=numvalue();
                        break;
                }
                case CROSSOVERPROBT:
                {
                        match(CROSSOVERPROBT);
                        match(EQUAL);
                        crossoverprob=numvalue();
                        break;
                }
                case SLOWNESST:
                {
                        match(SLOWNESST);
                        match(EQUAL);
                        slowness=numvalue();
                        break;
                }
                case OMEGAT:
                {
                        match(OMEGAT);
                        match(EQUAL);
                        omega=numvalue();
                        break;
                }
                case SIGMAT:
                {
                        match(SIGMAT);
                        match(EQUAL);
                        sigma=numvalue();
                        break;
                }
                case SHIFTT:
                {
                        match(SHIFTT);
                        match(EQUAL);
                        shift=numvalue();
                        break;
                }
                case CCT:
                {
                        match(CCT);
                        match(EQUAL);
                        cc=numvalue();
                        break;
                }
                case POISSONT:
                {
                        match(POISSONT);
                        match(EQUAL);
                        poisson=numvalue();
                        break;
                }
                case THREADST:
                {
                        match(THREADST);
                        match(EQUAL);
                        threads=numvalue();
                        break;
                }
                case STARTTIMET:
                {
                        match(STARTTIMET);
                        match(EQUAL);
                        starttime=numvalue();
                        break;
                }
                case ENDTIMET:
                {
                        match(ENDTIMET);
                        match(EQUAL);
                        endtime=numvalue();
                        break;
                }
                case TENSORERRORT:
                {
                        match(TENSORERRORT);
                        match(EQUAL);
                        tensorerror=numvalue();
                        break;
                }
                case RESERRORT:
                {
                        match(RESERRORT);
                        match(EQUAL);
                        reserror=numvalue();
                        break;
                }
                case PHASEERRORT:
                {
                        match(PHASEERRORT);
                        match(EQUAL);
                        phaseerror=numvalue();
                        break;
                }
                case RECERRORT:
                {
                        match(RECERRORT);
                        match(EQUAL);
                        recerror=numvalue();
                        break;
                }
                case RECMETHODT:
                {
                        match(RECMETHODT);
                        match(EQUAL);
                        recmethod=stringvalue();
                        break;
                }
                case GATYPET:
                {
                        match(GATYPET);
                        match(EQUAL);
                        gatype=stringvalue();
                        break;
                }
                case OUTPUTBASET:
                {
                        match(OUTPUTBASET);
                        match(EQUAL);
                        outputbase=stringvalue();
                        break;
                }
                case MODET:
                {
                        match(MODET);
                        match(EQUAL);
                        mode=stringvalue();
                        break;
                }
                case MTFITT:
                {
                        match(MTFITT);
                        match(EQUAL);
                        mtfit=stringvalue();
                        break;
                }
                case MTINPUTDATAT:
                {
                        match(MTINPUTDATAT);
                        match(EQUAL);
                        mtinputdata=stringvalue();
                        break;
                }
                case RECINPUTDATAT:
                {
                        match(RECINPUTDATAT);
                        match(EQUAL);
                        recinputdata=stringvalue();
                        break;
                }
                case RFABSVELDATAT:
                {
                        match(RFABSVELDATAT);
                        match(EQUAL);
                        rfabsveldata=stringvalue();
                        break;
                }
                case ANNEALINGGENERATIONT:
                {
                        match(ANNEALINGGENERATIONT);
                        match(EQUAL);
                        annealinggeneration=numvalue();
                        break;
                }
                case ELITISTT:
                {
                        match(ELITISTT);
                        match(EQUAL);
                        elitist=boolvalue();
                        break;
                }
                case THICKBASET:
                {
                        match(THICKBASET);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 107 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 284 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt138=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 108 "C1dInvGaConf.g"
                                                if (i < thickbase.size()) {thickbase.at(i) = dtemp;} else{thickbase.push_back(dtemp);}++i;
#line 294 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt138>=1 ) { goto _loop138; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt138++;
                        }
                        _loop138:;
                        }  // ( ... )+
                        break;
                }
                case THICKSTEPT:
                {
                        match(THICKSTEPT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 109 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 314 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt144=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 110 "C1dInvGaConf.g"
                                                if (i < thickstep.size()) {thickstep.at(i) = dtemp;} else{thickstep.push_back(dtemp);}++i;
#line 324 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt144>=1 ) { goto _loop144; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt144++;
                        }
                        _loop144:;
                        }  // ( ... )+
                        break;
                }
                case THICKSIZEST:
                {
                        match(THICKSIZEST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 111 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 344 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt150=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        itemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 112 "C1dInvGaConf.g"
                                                if (i < thicksizes.size()) {thicksizes.at(i) = itemp;} else{thicksizes.push_back(itemp);}++i;
#line 354 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt150>=1 ) { goto _loop150; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt150++;
                        }
                        _loop150:;
                        }  // ( ... )+
                        break;
                }
                case RESBASET:
                {
                        match(RESBASET);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 113 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 374 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt156=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 114 "C1dInvGaConf.g"
                                                if (i < resbase.size()) {resbase.at(i) = dtemp;} else{resbase.push_back(dtemp);}++i;
#line 384 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt156>=1 ) { goto _loop156; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt156++;
                        }
                        _loop156:;
                        }  // ( ... )+
                        break;
                }
                case RESSTEPT:
                {
                        match(RESSTEPT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 115 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 404 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt162=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 116 "C1dInvGaConf.g"
                                                if (i < resstep.size()) {resstep.at(i) = dtemp;} else{resstep.push_back(dtemp);}++i;
#line 414 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt162>=1 ) { goto _loop162; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt162++;
                        }
                        _loop162:;
                        }  // ( ... )+
                        break;
                }
                case RESSIZEST:
                {
                        match(RESSIZEST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 117 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 434 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt168=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        itemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 118 "C1dInvGaConf.g"
                                                if (i < ressizes.size()) {ressizes.at(i) = itemp;} else{ressizes.push_back(itemp);}++i;
#line 444 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt168>=1 ) { goto _loop168; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt168++;
                        }
                        _loop168:;
                        }  // ( ... )+
                        break;
                }
                case SVELBASET:
                {
                        match(SVELBASET);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 119 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 464 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt174=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 120 "C1dInvGaConf.g"
                                                if (i < svelbase.size()) {svelbase.at(i) = dtemp;} else{svelbase.push_back(dtemp);}++i;
#line 474 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt174>=1 ) { goto _loop174; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt174++;
                        }
                        _loop174:;
                        }  // ( ... )+
                        break;
                }
                case SVELSTEPT:
                {
                        match(SVELSTEPT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 121 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 494 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt180=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 122 "C1dInvGaConf.g"
                                                if (i < svelstep.size()) {svelstep.at(i) = dtemp;} else{svelstep.push_back(dtemp);}++i;
#line 504 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt180>=1 ) { goto _loop180; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt180++;
                        }
                        _loop180:;
                        }  // ( ... )+
                        break;
                }
                case SVELSIZEST:
                {
                        match(SVELSIZEST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 123 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 524 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt186=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        itemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 124 "C1dInvGaConf.g"
                                                if (i < svelsizes.size()) {svelsizes.at(i) = itemp;} else{svelsizes.push_back(itemp);}++i;
#line 534 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt186>=1 ) { goto _loop186; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt186++;
                        }
                        _loop186:;
                        }  // ( ... )+
                        break;
                }
                case WEIGHTST:
                {
                        match(WEIGHTST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 125 "C1dInvGaConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 554 "C1dInvGaConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt192=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 126 "C1dInvGaConf.g"
                                                if (i < weights.size()) {weights.at(i) = dtemp;} else{weights.push_back(dtemp);}++i;
#line 564 "C1dInvGaConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt192>=1 ) { goto _loop192; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt192++;
                        }
                        _loop192:;
                        }  // ( ... )+
                        break;
                }
                case RECWEIGHTT:
                {
                        match(RECWEIGHTT);
                        match(EQUAL);
                        recweight=numvalue();
                        break;
                }
                case ABSVELWEIGHTT:
                {
                        match(ABSVELWEIGHTT);
                        match(EQUAL);
                        absvelweight=numvalue();
                        break;
                }
                default:
                {
                        throw antlr::NoViableAltException(LT(1), getFilename());
                }
                }
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
}

bool  C1dInvGaConfParser::boolvalue() {
#line 143 "C1dInvGaConf.g"
        bool r;
#line 611 "C1dInvGaConfParser.cpp"
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                case TRUE:
                {
                        match(TRUE);
                        if ( inputState->guessing==0 ) {
#line 144 "C1dInvGaConf.g"
                                r = true;
#line 622 "C1dInvGaConfParser.cpp"
                        }
                        break;
                }
                case FALSE:
                {
                        match(FALSE);
                        if ( inputState->guessing==0 ) {
#line 144 "C1dInvGaConf.g"
                                r = false;
#line 632 "C1dInvGaConfParser.cpp"
                        }
                        break;
                }
                default:
                {
                        throw antlr::NoViableAltException(LT(1), getFilename());
                }
                }
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
        return r;
}

std::string  C1dInvGaConfParser::stringvalue() {
#line 147 "C1dInvGaConf.g"
        std::string r;
#line 657 "C1dInvGaConfParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(STRING);
                if ( inputState->guessing==0 ) {
#line 148 "C1dInvGaConf.g"
                        r = currvalue->getText();
#line 666 "C1dInvGaConfParser.cpp"
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
        return r;
}

double  C1dInvGaConfParser::numvalue() {
#line 139 "C1dInvGaConf.g"
        double r;
#line 683 "C1dInvGaConfParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(NUMBER);
                if ( inputState->guessing==0 ) {
#line 140 "C1dInvGaConf.g"
                        r = atof(currvalue->getText().c_str());
#line 692 "C1dInvGaConfParser.cpp"
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_1);
                } else {
                        throw;
                }
        }
        return r;
}

void C1dInvGaConfParser::configfile() {
#line 130 "C1dInvGaConf.g"
        
        verbose = false;
        usevrefmodel = false;
        mtfitexponent = 2;
        recfitexponent = 2;
        
#line 714 "C1dInvGaConfParser.cpp"
        
        try {      // for error handling
                { // ( ... )+
                int _cnt204=0;
                for (;;) {
                        if ((_tokenSet_2.member(LA(1)))) {
                                configentry();
                                {
                                if ((LA(1) == COMMENT) && (_tokenSet_0.member(LA(2))) && (LA(3) == antlr::Token::EOF_TYPE || LA(3) == EQUAL || LA(3) == COMMENT) && (_tokenSet_3.member(LA(4))) && (_tokenSet_1.member(LA(5))) && (_tokenSet_4.member(LA(6))) && (_tokenSet_5.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_5.member(LA(9))) && (_tokenSet_5.member(LA(10)))) {
                                        match(COMMENT);
                                }
                                else if ((_tokenSet_0.member(LA(1))) && (LA(2) == antlr::Token::EOF_TYPE || LA(2) == EQUAL || LA(2) == COMMENT) && (_tokenSet_3.member(LA(3))) && (_tokenSet_1.member(LA(4))) && (_tokenSet_4.member(LA(5))) && (_tokenSet_5.member(LA(6))) && (_tokenSet_5.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_5.member(LA(9))) && (_tokenSet_5.member(LA(10)))) {
                                }
                                else {
                                        throw antlr::NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                        }
                        else {
                                if ( _cnt204>=1 ) { goto _loop204; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt204++;
                }
                _loop204:;
                }  // ( ... )+
                { // ( ... )*
                for (;;) {
                        if ((LA(1) == COMMENT)) {
                                match(COMMENT);
                        }
                        else {
                                goto _loop206;
                        }
                        
                }
                _loop206:;
                } // ( ... )*
                match(antlr::Token::EOF_TYPE);
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_6);
                } else {
                        throw;
                }
        }
}

void C1dInvGaConfParser::initializeASTFactory( antlr::ASTFactory& )
{
}
const char* C1dInvGaConfParser::tokenNames[] = {
        "<0>",
        "EOF",
        "<2>",
        "NULL_TREE_LOOKAHEAD",
        "VERBOSET",
        "EQUAL",
        "USEVREFMODELT",
        "VREFMODELT",
        "STRING",
        "MTFITEXPONENTT",
        "NUMBER",
        "RECFITEXPONENTT",
        "POPSIZET",
        "INITTEMPT",
        "COOLINGRATIOT",
        "GENERATIONST",
        "MUTATIONPROBT",
        "CROSSOVERPROBT",
        "SLOWNESST",
        "OMEGAT",
        "SIGMAT",
        "SHIFTT",
        "CCT",
        "POISSONT",
        "THREADST",
        "STARTTIMET",
        "ENDTIMET",
        "TENSORERRORT",
        "RESERRORT",
        "PHASEERRORT",
        "RECERRORT",
        "RECMETHODT",
        "GATYPET",
        "OUTPUTBASET",
        "MODET",
        "MTFITT",
        "MTINPUTDATAT",
        "RECINPUTDATAT",
        "RFABSVELDATAT",
        "ANNEALINGGENERATIONT",
        "ELITISTT",
        "THICKBASET",
        "THICKSTEPT",
        "THICKSIZEST",
        "RESBASET",
        "RESSTEPT",
        "RESSIZEST",
        "SVELBASET",
        "SVELSTEPT",
        "SVELSIZEST",
        "WEIGHTST",
        "RECWEIGHTT",
        "ABSVELWEIGHTT",
        "COMMENT",
        "TRUE",
        "FALSE",
        "WS",
        "NEWLINE",
        "REAL",
        "INT",
        "DIGIT",
        "CHAR",
        "OTHER",
        0
};

const unsigned long C1dInvGaConfParser::_tokenSet_0_data_[] = { 4294965970UL, 4194303UL, 0UL, 0UL };
// EOF VERBOSET USEVREFMODELT VREFMODELT MTFITEXPONENTT RECFITEXPONENTT 
// POPSIZET INITTEMPT COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT 
// SLOWNESST OMEGAT SIGMAT SHIFTT CCT POISSONT THREADST STARTTIMET ENDTIMET 
// TENSORERRORT RESERRORT PHASEERRORT RECERRORT RECMETHODT GATYPET OUTPUTBASET 
// MODET MTFITT MTINPUTDATAT RECINPUTDATAT RFABSVELDATAT ANNEALINGGENERATIONT 
// ELITISTT THICKBASET THICKSTEPT THICKSIZEST RESBASET RESSTEPT RESSIZEST 
// SVELBASET SVELSTEPT SVELSIZEST WEIGHTST RECWEIGHTT ABSVELWEIGHTT COMMENT 
const antlr::BitSet C1dInvGaConfParser::_tokenSet_0(_tokenSet_0_data_,4);
const unsigned long C1dInvGaConfParser::_tokenSet_1_data_[] = { 4294966994UL, 4194303UL, 0UL, 0UL };
// EOF VERBOSET USEVREFMODELT VREFMODELT MTFITEXPONENTT NUMBER RECFITEXPONENTT 
// POPSIZET INITTEMPT COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT 
// SLOWNESST OMEGAT SIGMAT SHIFTT CCT POISSONT THREADST STARTTIMET ENDTIMET 
// TENSORERRORT RESERRORT PHASEERRORT RECERRORT RECMETHODT GATYPET OUTPUTBASET 
// MODET MTFITT MTINPUTDATAT RECINPUTDATAT RFABSVELDATAT ANNEALINGGENERATIONT 
// ELITISTT THICKBASET THICKSTEPT THICKSIZEST RESBASET RESSTEPT RESSIZEST 
// SVELBASET SVELSTEPT SVELSIZEST WEIGHTST RECWEIGHTT ABSVELWEIGHTT COMMENT 
const antlr::BitSet C1dInvGaConfParser::_tokenSet_1(_tokenSet_1_data_,4);
const unsigned long C1dInvGaConfParser::_tokenSet_2_data_[] = { 4294965968UL, 2097151UL, 0UL, 0UL };
// VERBOSET USEVREFMODELT VREFMODELT MTFITEXPONENTT RECFITEXPONENTT POPSIZET 
// INITTEMPT COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT SLOWNESST 
// OMEGAT SIGMAT SHIFTT CCT POISSONT THREADST STARTTIMET ENDTIMET TENSORERRORT 
// RESERRORT PHASEERRORT RECERRORT RECMETHODT GATYPET OUTPUTBASET MODET 
// MTFITT MTINPUTDATAT RECINPUTDATAT RFABSVELDATAT ANNEALINGGENERATIONT 
// ELITISTT THICKBASET THICKSTEPT THICKSIZEST RESBASET RESSTEPT RESSIZEST 
// SVELBASET SVELSTEPT SVELSIZEST WEIGHTST RECWEIGHTT ABSVELWEIGHTT 
const antlr::BitSet C1dInvGaConfParser::_tokenSet_2(_tokenSet_2_data_,4);
const unsigned long C1dInvGaConfParser::_tokenSet_3_data_[] = { 1282UL, 14680064UL, 0UL, 0UL };
// EOF STRING NUMBER COMMENT TRUE FALSE 
const antlr::BitSet C1dInvGaConfParser::_tokenSet_3(_tokenSet_3_data_,4);
const unsigned long C1dInvGaConfParser::_tokenSet_4_data_[] = { 4294967026UL, 4194303UL, 0UL, 0UL };
// EOF VERBOSET EQUAL USEVREFMODELT VREFMODELT MTFITEXPONENTT NUMBER RECFITEXPONENTT 
// POPSIZET INITTEMPT COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT 
// SLOWNESST OMEGAT SIGMAT SHIFTT CCT POISSONT THREADST STARTTIMET ENDTIMET 
// TENSORERRORT RESERRORT PHASEERRORT RECERRORT RECMETHODT GATYPET OUTPUTBASET 
// MODET MTFITT MTINPUTDATAT RECINPUTDATAT RFABSVELDATAT ANNEALINGGENERATIONT 
// ELITISTT THICKBASET THICKSTEPT THICKSIZEST RESBASET RESSTEPT RESSIZEST 
// SVELBASET SVELSTEPT SVELSIZEST WEIGHTST RECWEIGHTT ABSVELWEIGHTT COMMENT 
const antlr::BitSet C1dInvGaConfParser::_tokenSet_4(_tokenSet_4_data_,4);
const unsigned long C1dInvGaConfParser::_tokenSet_5_data_[] = { 4294967282UL, 16777215UL, 0UL, 0UL };
// EOF VERBOSET EQUAL USEVREFMODELT VREFMODELT STRING MTFITEXPONENTT NUMBER 
// RECFITEXPONENTT POPSIZET INITTEMPT COOLINGRATIOT GENERATIONST MUTATIONPROBT 
// CROSSOVERPROBT SLOWNESST OMEGAT SIGMAT SHIFTT CCT POISSONT THREADST 
// STARTTIMET ENDTIMET TENSORERRORT RESERRORT PHASEERRORT RECERRORT RECMETHODT 
// GATYPET OUTPUTBASET MODET MTFITT MTINPUTDATAT RECINPUTDATAT RFABSVELDATAT 
// ANNEALINGGENERATIONT ELITISTT THICKBASET THICKSTEPT THICKSIZEST RESBASET 
// RESSTEPT RESSIZEST SVELBASET SVELSTEPT SVELSIZEST WEIGHTST RECWEIGHTT 
// ABSVELWEIGHTT COMMENT TRUE FALSE 
const antlr::BitSet C1dInvGaConfParser::_tokenSet_5(_tokenSet_5_data_,4);
const unsigned long C1dInvGaConfParser::_tokenSet_6_data_[] = { 2UL, 0UL, 0UL, 0UL };
// EOF 
const antlr::BitSet C1dInvGaConfParser::_tokenSet_6(_tokenSet_6_data_,4);

---