/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/* $ANTLR 2.7.7 (20130409): "CPP_parser.g" -> "CPPParser.cpp"$ */
#include "CPPParser.hpp"
#include <antlr/NoViableAltException.hpp>
#include <antlr/SemanticException.hpp>
#include <antlr/ASTFactory.hpp>
#line 102 "CPP_parser.g"

// File generated from CPP_parser.g
// Version 3.1 November 2005
// This file is best viewed in courier font with tabs set to 4 spaces
//
// The statements in this block appear only in CPPParser.cpp and not in
// CPPLexer.cpp

// These constants used in the previous version (3.0 July 2004) have now been
// replaced by the following,
// ID_VAR_NAME is now CPPSymbol::otVariable
// ID_FUN_NAME is now CPPSymbol::otFunction
// ID_INPUT_PARAMETER is now not used
// ID_CLASS_DEF is now CPPSymbol::otClass
// ID_SYSTEM_FUNCTION is now not used
// ID_CONST_DECL is now not used
// ID_TYPEDEF_VAR is now CPPSymbol::otTypedef

int statementTrace =
    2;  // Used to control selected (level) tracing (see support.cpp)
// 1 Shows which external and member statements selected
// 2 Shows above plus all declarations/definitions
// 3 reserved for future use
// 4 and above available for user

void CPPParser::init() {
  antlrTrace(false);  // This is a dynamic trace facility for use with
                      // -traceParser etc.
  // It requires modification in LLkParser.cpp and LLkParser.hpp
  // otherwise it should be commented out (see MyReadMe.txt)
  // true shows antlr trace (or can be set and reset during parsing)
  // false stops showing antlr trace
  // Provided the parser is always generated with -traceParser this
  // facility allows trace output to be turned on or off by changing
  // the setting here from false to true or vice versa and then
  // recompiling and linking CPPParser only thus avoiding the need
  // to use antlr.Tool to re-generate the lexer and parser again
  // with (or without) -traceParser.
  // Antlr trace can also be turned on and off dynamically using
  // antlrTrace_on or antlrTrace_off statements inserted into the
  // source code being parsed (See below).

  // Creates a dictionary to hold symbols with 4001 buckets, 200 scopes and
  // 800,000 characters
  // These can be changed to suit the size of program(s) being parsed
  symbols = new CPPDictionary(4001, 200, 800000);

  // Set template parameter scope - Not used at present
  templateParameterScope =
      symbols->getCurrentScopeIndex();  // Set template parameter scope to 0

  symbols->saveScope();  // Advance currentScope from 0 to 1
  // Set "external" scope for all types
  externalScope =
      symbols->getCurrentScopeIndex();  // Set "external" scope to 1 for types

  // Declare predefined scope "std" in external scope
  CPPSymbol* a = new CPPSymbol("std", CPPSymbol::otTypedef);
  symbols->define("std", a);

  symbols->saveScope();  // Advance currentScope from 1 to 2 (and higher) for
                         // all other symbols
  // treated as locals

  // Global flags to allow for nested declarations
  _td = false;      // For typedef
  _fd = false;      // For friend
  _sc = scInvalid;  // For StorageClass
  _tq = tqInvalid;  // For TypeQualifier
  _ts = tsInvalid;  // For TypeSpecifier
  _fs = fsInvalid;  // For FunctionSpecifier

  functionDefinition = 0;
  qualifierPrefix[0] = '\0';
  enclosingClass = (char*)"";
  assign_stmt_RHS_found = 0;
  in_parameter_list = false;
  K_and_R = false;  // used to distinguish old K & R parameter definitions
  in_return = false;
  is_address = false;
  is_pointer = false;
}

#line 85 "CPPParser.cpp"
CPPParser::CPPParser(ANTLR_USE_NAMESPACE(antlr) TokenBuffer& tokenBuf, int k)
    : ANTLR_USE_NAMESPACE(antlr) LLkParser(tokenBuf, k) {}

CPPParser::CPPParser(ANTLR_USE_NAMESPACE(antlr) TokenBuffer& tokenBuf)
    : ANTLR_USE_NAMESPACE(antlr) LLkParser(tokenBuf, 2) {}

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

CPPParser::CPPParser(ANTLR_USE_NAMESPACE(antlr) TokenStream& lexer)
    : ANTLR_USE_NAMESPACE(antlr) LLkParser(lexer, 2) {}

CPPParser::CPPParser(const ANTLR_USE_NAMESPACE(antlr)
                         ParserSharedInputState& state)
    : ANTLR_USE_NAMESPACE(antlr) LLkParser(state, 2) {}

void CPPParser::translation_unit() {
  try {  // for error handling
    if (inputState->guessing == 0) {
#line 376 "CPP_parser.g"
      enterExternalScope();
#line 117 "CPPParser.cpp"
    }
    {  // ( ... )+
      int _cnt3 = 0;
      for (;;) {
        if ((_tokenSet_0.member(LA(1)))) {
          external_declaration();
        } else {
          if (_cnt3 >= 1) {
            goto _loop3;
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }

        _cnt3++;
      }
    _loop3:;
    }  // ( ... )+
    match(ANTLR_USE_NAMESPACE(antlr) Token::EOF_TYPE);
    if (inputState->guessing == 0) {
#line 378 "CPP_parser.g"
      exitExternalScope();
#line 137 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_1);
    } else {
      throw;
    }
  }
}

void CPPParser::external_declaration() {
#line 381 "CPP_parser.g"
  char* s;
  K_and_R = false;
  FunctionSpecifier fs = fsInvalid;  // inline,virtual,explicit

#line 156 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_namespace: {
          if (inputState->guessing == 0) {
#line 539 "CPP_parser.g"
            if (statementTrace >= 1) {
              printf("%d external_declaration Namespace definition\n",
                     LT(1)->getLine());
            }

#line 168 "CPPParser.cpp"
          }
          match(LITERAL_namespace);
          namespace_definition();
          break;
        }
        case SEMICOLON: {
          if (inputState->guessing == 0) {
#line 551 "CPP_parser.g"
            if (statementTrace >= 1) {
              printf("%d external_declaration Semicolon\n", LT(1)->getLine());
            }

#line 181 "CPPParser.cpp"
          }
          match(SEMICOLON);
          if (inputState->guessing == 0) {
#line 554 "CPP_parser.g"
            end_of_stmt();
#line 187 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_antlrTrace_on: {
          match(LITERAL_antlrTrace_on);
          if (inputState->guessing == 0) {
#line 558 "CPP_parser.g"
            antlrTrace(true);
#line 197 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_antlrTrace_off: {
          match(LITERAL_antlrTrace_off);
          if (inputState->guessing == 0) {
#line 561 "CPP_parser.g"
            antlrTrace(false);
#line 207 "CPPParser.cpp"
          }
          break;
        }
        default:
          bool synPredMatched7 = false;
          if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) {
            int _m7 = mark();
            synPredMatched7 = true;
            inputState->guessing++;
            try {
              {
                match(LITERAL_template);
                match(LESSTHAN);
                match(GREATERTHAN);
              }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched7 = false;
            }
            rewind(_m7);
            inputState->guessing--;
          }
          if (synPredMatched7) {
            if (inputState->guessing == 0) {
#line 390 "CPP_parser.g"
              if (statementTrace >= 1) {
                printf(
                    "%d external_declaration template "
                    "explicit-specialisation\n",
                    LT(1)->getLine());
              }

#line 236 "CPPParser.cpp"
            }
            match(LITERAL_template);
            match(LESSTHAN);
            match(GREATERTHAN);
            external_declaration();
          } else {
            bool synPredMatched9 = false;
            if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) {
              int _m9 = mark();
              synPredMatched9 = true;
              inputState->guessing++;
              try {
                { match(LITERAL_typedef); }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched9 = false;
              }
              rewind(_m9);
              inputState->guessing--;
            }
            if (synPredMatched9) {
              {
                bool synPredMatched12 = false;
                if (((LA(1) == LITERAL_typedef) &&
                     ((LA(2) >= LITERAL_struct && LA(2) <= LITERAL_class)))) {
                  int _m12 = mark();
                  synPredMatched12 = true;
                  inputState->guessing++;
                  try {
                    {
                      match(LITERAL_typedef);
                      class_specifier();
                    }
                  } catch (ANTLR_USE_NAMESPACE(antlr)
                               RecognitionException& pe) {
                    synPredMatched12 = false;
                  }
                  rewind(_m12);
                  inputState->guessing--;
                }
                if (synPredMatched12) {
                  if (inputState->guessing == 0) {
#line 399 "CPP_parser.g"
                    if (statementTrace >= 1) {
                      printf("%d external_declaration Typedef class type\n",
                             LT(1)->getLine());
                    }

#line 285 "CPPParser.cpp"
                  }
                  match(LITERAL_typedef);
                  class_decl_or_def(fs);
                  if (inputState->guessing == 0) {
#line 402 "CPP_parser.g"
                    _td = true;
#line 292 "CPPParser.cpp"
                  }
                  {
                    switch (LA(1)) {
                      case ID:
                      case LITERAL__stdcall:
                      case LITERAL___stdcall:
                      case LPAREN:
                      case OPERATOR:
                      case LITERAL_this:
                      case LITERAL_true:
                      case LITERAL_false:
                      case TILDE:
                      case STAR:
                      case AMPERSAND:
                      case SCOPE:
                      case LITERAL__cdecl:
                      case LITERAL___cdecl:
                      case LITERAL__near:
                      case LITERAL___near:
                      case LITERAL__far:
                      case LITERAL___far:
                      case LITERAL___interrupt:
                      case LITERAL_pascal:
                      case LITERAL__pascal:
                      case LITERAL___pascal: {
                        init_declarator_list();
                        break;
                      }
                      case SEMICOLON: {
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  match(SEMICOLON);
                  if (inputState->guessing == 0) {
#line 402 "CPP_parser.g"
                    end_of_stmt();
#line 336 "CPPParser.cpp"
                  }
                } else {
                  bool synPredMatched15 = false;
                  if (((LA(1) == LITERAL_typedef) && (LA(2) == LITERAL_enum))) {
                    int _m15 = mark();
                    synPredMatched15 = true;
                    inputState->guessing++;
                    try {
                      {
                        match(LITERAL_typedef);
                        match(LITERAL_enum);
                      }
                    } catch (ANTLR_USE_NAMESPACE(antlr)
                                 RecognitionException& pe) {
                      synPredMatched15 = false;
                    }
                    rewind(_m15);
                    inputState->guessing--;
                  }
                  if (synPredMatched15) {
                    if (inputState->guessing == 0) {
#line 405 "CPP_parser.g"
                      if (statementTrace >= 1) {
                        printf("%d external_declaration Typedef enum type\n",
                               LT(1)->getLine());
                      }

#line 363 "CPPParser.cpp"
                    }
                    match(LITERAL_typedef);
                    enum_specifier();
                    if (inputState->guessing == 0) {
#line 408 "CPP_parser.g"
                      _td = true;
#line 370 "CPPParser.cpp"
                    }
                    {
                      switch (LA(1)) {
                        case ID:
                        case LITERAL__stdcall:
                        case LITERAL___stdcall:
                        case LPAREN:
                        case OPERATOR:
                        case LITERAL_this:
                        case LITERAL_true:
                        case LITERAL_false:
                        case TILDE:
                        case STAR:
                        case AMPERSAND:
                        case SCOPE:
                        case LITERAL__cdecl:
                        case LITERAL___cdecl:
                        case LITERAL__near:
                        case LITERAL___near:
                        case LITERAL__far:
                        case LITERAL___far:
                        case LITERAL___interrupt:
                        case LITERAL_pascal:
                        case LITERAL__pascal:
                        case LITERAL___pascal: {
                          init_declarator_list();
                          break;
                        }
                        case SEMICOLON: {
                          break;
                        }
                        default: {
                          throw ANTLR_USE_NAMESPACE(antlr)
                              NoViableAltException(LT(1), getFilename());
                        }
                      }
                    }
                    match(SEMICOLON);
                    if (inputState->guessing == 0) {
#line 408 "CPP_parser.g"
                      end_of_stmt();
#line 414 "CPPParser.cpp"
                    }
                  } else {
                    bool synPredMatched18 = false;
                    if (((_tokenSet_2.member(LA(1))) &&
                         (_tokenSet_3.member(LA(2))))) {
                      int _m18 = mark();
                      synPredMatched18 = true;
                      inputState->guessing++;
                      try {
                        {
                          declaration_specifiers();
                          function_declarator(0);
                          match(SEMICOLON);
                        }
                      } catch (ANTLR_USE_NAMESPACE(antlr)
                                   RecognitionException& pe) {
                        synPredMatched18 = false;
                      }
                      rewind(_m18);
                      inputState->guessing--;
                    }
                    if (synPredMatched18) {
                      if (inputState->guessing == 0) {
#line 411 "CPP_parser.g"
                        if (statementTrace >= 1) {
                          printf(
                              "%d external_declaration Typedef function type\n",
                              LT(1)->getLine());
                        }

#line 442 "CPPParser.cpp"
                      }
                      declaration();
                    } else if ((_tokenSet_2.member(LA(1))) &&
                               (_tokenSet_3.member(LA(2)))) {
                      if (inputState->guessing == 0) {
#line 416 "CPP_parser.g"
                        if (statementTrace >= 1) {
                          printf(
                              "%d external_declaration Typedef variable type\n",
                              LT(1)->getLine());
                        }

#line 452 "CPPParser.cpp"
                      }
                      declaration();
                    } else {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }
                }
              }
            } else {
              bool synPredMatched22 = false;
              if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) {
                int _m22 = mark();
                synPredMatched22 = true;
                inputState->guessing++;
                try {
                  {
                    template_head();
                    {  // ( ... )*
                      for (;;) {
                        if ((_tokenSet_4.member(LA(1)))) {
                          fs = function_specifier();
                        } else {
                          goto _loop21;
                        }
                      }
                    _loop21:;
                    }  // ( ... )*
                    class_specifier();
                  }
                } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                  synPredMatched22 = false;
                }
                rewind(_m22);
                inputState->guessing--;
              }
              if (synPredMatched22) {
                if (inputState->guessing == 0) {
#line 424 "CPP_parser.g"
                  if (statementTrace >= 1) {
                    printf(
                        "%d external_declaration Templated class decl or def\n",
                        LT(1)->getLine());
                  }

#line 498 "CPPParser.cpp"
                }
                template_head();
                {  // ( ... )*
                  for (;;) {
                    if ((_tokenSet_4.member(LA(1)))) {
                      fs = function_specifier();
                    } else {
                      goto _loop24;
                    }
                  }
                _loop24:;
                }  // ( ... )*
                class_decl_or_def(fs);
                {
                  switch (LA(1)) {
                    case ID:
                    case LITERAL__stdcall:
                    case LITERAL___stdcall:
                    case LPAREN:
                    case OPERATOR:
                    case LITERAL_this:
                    case LITERAL_true:
                    case LITERAL_false:
                    case TILDE:
                    case STAR:
                    case AMPERSAND:
                    case SCOPE:
                    case LITERAL__cdecl:
                    case LITERAL___cdecl:
                    case LITERAL__near:
                    case LITERAL___near:
                    case LITERAL__far:
                    case LITERAL___far:
                    case LITERAL___interrupt:
                    case LITERAL_pascal:
                    case LITERAL__pascal:
                    case LITERAL___pascal: {
                      init_declarator_list();
                      break;
                    }
                    case SEMICOLON: {
                      break;
                    }
                    default: {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }
                }
                match(SEMICOLON);
                if (inputState->guessing == 0) {
#line 427 "CPP_parser.g"
                  end_of_stmt();
#line 556 "CPPParser.cpp"
                }
              } else {
                bool synPredMatched28 = false;
                if (((LA(1) == LITERAL_enum) && (_tokenSet_5.member(LA(2))))) {
                  int _m28 = mark();
                  synPredMatched28 = true;
                  inputState->guessing++;
                  try {
                    {
                      match(LITERAL_enum);
                      {
                        switch (LA(1)) {
                          case ID: {
                            match(ID);
                            break;
                          }
                          case LCURLY: {
                            break;
                          }
                          default: {
                            throw ANTLR_USE_NAMESPACE(antlr)
                                NoViableAltException(LT(1), getFilename());
                          }
                        }
                      }
                      match(LCURLY);
                    }
                  } catch (ANTLR_USE_NAMESPACE(antlr)
                               RecognitionException& pe) {
                    synPredMatched28 = false;
                  }
                  rewind(_m28);
                  inputState->guessing--;
                }
                if (synPredMatched28) {
                  if (inputState->guessing == 0) {
#line 431 "CPP_parser.g"
                    if (statementTrace >= 1) {
                      printf("%d external_declaration Enum definition\n",
                             LT(1)->getLine());
                    }

#line 600 "CPPParser.cpp"
                  }
                  enum_specifier();
                  {
                    switch (LA(1)) {
                      case ID:
                      case LITERAL__stdcall:
                      case LITERAL___stdcall:
                      case LPAREN:
                      case OPERATOR:
                      case LITERAL_this:
                      case LITERAL_true:
                      case LITERAL_false:
                      case TILDE:
                      case STAR:
                      case AMPERSAND:
                      case SCOPE:
                      case LITERAL__cdecl:
                      case LITERAL___cdecl:
                      case LITERAL__near:
                      case LITERAL___near:
                      case LITERAL__far:
                      case LITERAL___far:
                      case LITERAL___interrupt:
                      case LITERAL_pascal:
                      case LITERAL__pascal:
                      case LITERAL___pascal: {
                        init_declarator_list();
                        break;
                      }
                      case SEMICOLON: {
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  match(SEMICOLON);
                  if (inputState->guessing == 0) {
#line 434 "CPP_parser.g"
                    end_of_stmt();
#line 645 "CPPParser.cpp"
                  }
                } else {
                  bool synPredMatched32 = false;
                  if (((_tokenSet_6.member(LA(1))) &&
                       (_tokenSet_7.member(LA(2))))) {
                    int _m32 = mark();
                    synPredMatched32 = true;
                    inputState->guessing++;
                    try {
                      {
                        {
                          switch (LA(1)) {
                            case LITERAL_template: {
                              template_head();
                              break;
                            }
                            case ID:
                            case LITERAL_inline:
                            case LITERAL__inline:
                            case LITERAL___inline:
                            case LITERAL_virtual:
                            case TILDE:
                            case SCOPE: {
                              break;
                            }
                            default: {
                              throw ANTLR_USE_NAMESPACE(antlr)
                                  NoViableAltException(LT(1), getFilename());
                            }
                          }
                        }
                        dtor_head(1);
                        match(LCURLY);
                      }
                    } catch (ANTLR_USE_NAMESPACE(antlr)
                                 RecognitionException& pe) {
                      synPredMatched32 = false;
                    }
                    rewind(_m32);
                    inputState->guessing--;
                  }
                  if (synPredMatched32) {
                    if (inputState->guessing == 0) {
#line 438 "CPP_parser.g"
                      if (statementTrace >= 1) {
                        printf(
                            "%d external_declaration Destructor definition\n",
                            LT(1)->getLine());
                      }

#line 695 "CPPParser.cpp"
                    }
                    {
                      switch (LA(1)) {
                        case LITERAL_template: {
                          template_head();
                          break;
                        }
                        case ID:
                        case LITERAL_inline:
                        case LITERAL__inline:
                        case LITERAL___inline:
                        case LITERAL_virtual:
                        case TILDE:
                        case SCOPE: {
                          break;
                        }
                        default: {
                          throw ANTLR_USE_NAMESPACE(antlr)
                              NoViableAltException(LT(1), getFilename());
                        }
                      }
                    }
                    dtor_head(1);
                    dtor_body();
                  } else {
                    bool synPredMatched36 = false;
                    if (((_tokenSet_8.member(LA(1))) &&
                         (_tokenSet_9.member(LA(2))))) {
                      int _m36 = mark();
                      synPredMatched36 = true;
                      inputState->guessing++;
                      try {
                        {
                          {
                            if ((true) && (true)) {
                              ctor_decl_spec();
                            } else {
                            }
                          }
                          if (!(qualifiedItemIsOneOf(qiCtor))) {
                            throw ANTLR_USE_NAMESPACE(antlr) SemanticException(
                                "qualifiedItemIsOneOf(qiCtor)");
                          }
                        }
                      } catch (ANTLR_USE_NAMESPACE(antlr)
                                   RecognitionException& pe) {
                        synPredMatched36 = false;
                      }
                      rewind(_m36);
                      inputState->guessing--;
                    }
                    if (synPredMatched36) {
                      if (inputState->guessing == 0) {
#line 451 "CPP_parser.g"
                        if (statementTrace >= 1) {
                          printf(
                              "%d external_declaration Constructor "
                              "definition\n",
                              LT(1)->getLine());
                        }

#line 755 "CPPParser.cpp"
                      }
                      ctor_definition();
                    } else {
                      bool synPredMatched39 = false;
                      if (((_tokenSet_10.member(LA(1))) &&
                           (_tokenSet_11.member(LA(2))))) {
                        int _m39 = mark();
                        synPredMatched39 = true;
                        inputState->guessing++;
                        try {
                          {
                            {
                              switch (LA(1)) {
                                case LITERAL_inline: {
                                  match(LITERAL_inline);
                                  break;
                                }
                                case ID:
                                case OPERATOR:
                                case SCOPE: {
                                  break;
                                }
                                default: {
                                  throw ANTLR_USE_NAMESPACE(antlr)
                                      NoViableAltException(LT(1),
                                                           getFilename());
                                }
                              }
                            }
                            scope_override();
                            conversion_function_decl_or_def();
                          }
                        } catch (ANTLR_USE_NAMESPACE(antlr)
                                     RecognitionException& pe) {
                          synPredMatched39 = false;
                        }
                        rewind(_m39);
                        inputState->guessing--;
                      }
                      if (synPredMatched39) {
                        if (inputState->guessing == 0) {
#line 458 "CPP_parser.g"
                          if (statementTrace >= 1) {
                            printf(
                                "%d external_declaration Operator function\n",
                                LT(1)->getLine());
                          }

#line 802 "CPPParser.cpp"
                        }
                        {
                          switch (LA(1)) {
                            case LITERAL_inline: {
                              match(LITERAL_inline);
                              break;
                            }
                            case ID:
                            case OPERATOR:
                            case SCOPE: {
                              break;
                            }
                            default: {
                              throw ANTLR_USE_NAMESPACE(antlr)
                                  NoViableAltException(LT(1), getFilename());
                            }
                          }
                        }
                        s = scope_override();
                        conversion_function_decl_or_def();
                      } else {
                        bool synPredMatched42 = false;
                        if (((_tokenSet_12.member(LA(1))) &&
                             (_tokenSet_13.member(LA(2))))) {
                          int _m42 = mark();
                          synPredMatched42 = true;
                          inputState->guessing++;
                          try {
                            {
                              declaration_specifiers();
                              function_declarator(0);
                              match(SEMICOLON);
                            }
                          } catch (ANTLR_USE_NAMESPACE(antlr)
                                       RecognitionException& pe) {
                            synPredMatched42 = false;
                          }
                          rewind(_m42);
                          inputState->guessing--;
                        }
                        if (synPredMatched42) {
                          if (inputState->guessing == 0) {
#line 465 "CPP_parser.g"
                            if (statementTrace >= 1) {
                              printf(
                                  "%d external_declaration Function "
                                  "declaration\n",
                                  LT(1)->getLine());
                            }

#line 851 "CPPParser.cpp"
                          }
                          declaration_specifiers();
                          function_declarator(0);
                          match(SEMICOLON);
                          if (inputState->guessing == 0) {
#line 468 "CPP_parser.g"
                            end_of_stmt();
#line 859 "CPPParser.cpp"
                          }
                        } else {
                          bool synPredMatched44 = false;
                          if (((_tokenSet_14.member(LA(1))) &&
                               (_tokenSet_15.member(LA(2))))) {
                            int _m44 = mark();
                            synPredMatched44 = true;
                            inputState->guessing++;
                            try {
                              {
                                declaration_specifiers();
                                function_declarator(1);
                                match(LCURLY);
                              }
                            } catch (ANTLR_USE_NAMESPACE(antlr)
                                         RecognitionException& pe) {
                              synPredMatched44 = false;
                            }
                            rewind(_m44);
                            inputState->guessing--;
                          }
                          if (synPredMatched44) {
                            if (inputState->guessing == 0) {
#line 472 "CPP_parser.g"
                              if (statementTrace >= 1) {
                                printf(
                                    "%d external_declaration Function "
                                    "definition\n",
                                    LT(1)->getLine());
                              }

#line 887 "CPPParser.cpp"
                            }
                            function_definition();
                          } else {
                            bool synPredMatched46 = false;
                            if (((_tokenSet_14.member(LA(1))) &&
                                 (_tokenSet_15.member(LA(2))))) {
                              int _m46 = mark();
                              synPredMatched46 = true;
                              inputState->guessing++;
                              try {
                                {
                                  declaration_specifiers();
                                  function_declarator(1);
                                  declaration();
                                }
                              } catch (ANTLR_USE_NAMESPACE(antlr)
                                           RecognitionException& pe) {
                                synPredMatched46 = false;
                              }
                              rewind(_m46);
                              inputState->guessing--;
                            }
                            if (synPredMatched46) {
                              if (inputState->guessing == 0) {
#line 479 "CPP_parser.g"
                                K_and_R = true;
                                if (statementTrace >= 1) {
                                  printf(
                                      "%d external_declaration K & R function "
                                      "definition\n",
                                      LT(1)->getLine());
                                }

#line 917 "CPPParser.cpp"
                              }
                              function_definition();
                            } else {
                              bool synPredMatched48 = false;
                              if (((_tokenSet_14.member(LA(1))) &&
                                   (_tokenSet_15.member(LA(2))))) {
                                int _m48 = mark();
                                synPredMatched48 = true;
                                inputState->guessing++;
                                try {
                                  {
                                    function_declarator(1);
                                    declaration();
                                  }
                                } catch (ANTLR_USE_NAMESPACE(antlr)
                                             RecognitionException& pe) {
                                  synPredMatched48 = false;
                                }
                                rewind(_m48);
                                inputState->guessing--;
                              }
                              if (synPredMatched48) {
                                if (inputState->guessing == 0) {
#line 487 "CPP_parser.g"
                                  K_and_R = true;
                                  if (statementTrace >= 1) {
                                    printf(
                                        "%d external_declaration K & R "
                                        "function definition without return "
                                        "type\n",
                                        LT(1)->getLine());
                                  }

#line 946 "CPPParser.cpp"
                                }
                                function_definition();
                              } else {
                                bool synPredMatched53 = false;
                                if (((_tokenSet_16.member(LA(1))) &&
                                     (_tokenSet_17.member(LA(2))))) {
                                  int _m53 = mark();
                                  synPredMatched53 = true;
                                  inputState->guessing++;
                                  try {
                                    {
                                      {
                                        switch (LA(1)) {
                                          case LITERAL_friend: {
                                            match(LITERAL_friend);
                                            break;
                                          }
                                          case LITERAL_inline:
                                          case LITERAL_struct:
                                          case LITERAL_union:
                                          case LITERAL_class:
                                          case LITERAL__inline:
                                          case LITERAL___inline:
                                          case LITERAL_virtual:
                                          case LITERAL_explicit: {
                                            break;
                                          }
                                          default: {
                                            throw ANTLR_USE_NAMESPACE(antlr)
                                                NoViableAltException(
                                                    LT(1), getFilename());
                                          }
                                        }
                                      }
                                      {  // ( ... )*
                                        for (;;) {
                                          if ((_tokenSet_4.member(LA(1)))) {
                                            fs = function_specifier();
                                          } else {
                                            goto _loop52;
                                          }
                                        }
                                      _loop52:;
                                      }  // ( ... )*
                                      class_specifier();
                                    }
                                  } catch (ANTLR_USE_NAMESPACE(antlr)
                                               RecognitionException& pe) {
                                    synPredMatched53 = false;
                                  }
                                  rewind(_m53);
                                  inputState->guessing--;
                                }
                                if (synPredMatched53) {
                                  if (inputState->guessing == 0) {
#line 495 "CPP_parser.g"
                                    if (statementTrace >= 1) {
                                      printf(
                                          "%d external_declaration Class decl "
                                          "or def\n",
                                          LT(1)->getLine());
                                    }

#line 1009 "CPPParser.cpp"
                                  }
                                  {
                                    switch (LA(1)) {
                                      case LITERAL_friend: {
                                        match(LITERAL_friend);
                                        break;
                                      }
                                      case LITERAL_inline:
                                      case LITERAL_struct:
                                      case LITERAL_union:
                                      case LITERAL_class:
                                      case LITERAL__inline:
                                      case LITERAL___inline:
                                      case LITERAL_virtual:
                                      case LITERAL_explicit: {
                                        break;
                                      }
                                      default: {
                                        throw ANTLR_USE_NAMESPACE(antlr)
                                            NoViableAltException(LT(1),
                                                                 getFilename());
                                      }
                                    }
                                  }
                                  {  // ( ... )*
                                    for (;;) {
                                      if ((_tokenSet_4.member(LA(1)))) {
                                        fs = function_specifier();
                                      } else {
                                        goto _loop56;
                                      }
                                    }
                                  _loop56:;
                                  }  // ( ... )*
                                  class_decl_or_def(fs);
                                  {
                                    switch (LA(1)) {
                                      case ID:
                                      case LITERAL__stdcall:
                                      case LITERAL___stdcall:
                                      case LPAREN:
                                      case OPERATOR:
                                      case LITERAL_this:
                                      case LITERAL_true:
                                      case LITERAL_false:
                                      case TILDE:
                                      case STAR:
                                      case AMPERSAND:
                                      case SCOPE:
                                      case LITERAL__cdecl:
                                      case LITERAL___cdecl:
                                      case LITERAL__near:
                                      case LITERAL___near:
                                      case LITERAL__far:
                                      case LITERAL___far:
                                      case LITERAL___interrupt:
                                      case LITERAL_pascal:
                                      case LITERAL__pascal:
                                      case LITERAL___pascal: {
                                        init_declarator_list();
                                        break;
                                      }
                                      case SEMICOLON: {
                                        break;
                                      }
                                      default: {
                                        throw ANTLR_USE_NAMESPACE(antlr)
                                            NoViableAltException(LT(1),
                                                                 getFilename());
                                      }
                                    }
                                  }
                                  match(SEMICOLON);
                                  if (inputState->guessing == 0) {
#line 498 "CPP_parser.g"
                                    end_of_stmt();
#line 1090 "CPPParser.cpp"
                                  }
                                } else if ((LA(1) == LITERAL_template) &&
                                           (LA(2) == LESSTHAN)) {
                                  if (inputState->guessing == 0) {
#line 501 "CPP_parser.g"
                                    beginTemplateDeclaration();
#line 1097 "CPPParser.cpp"
                                  }
                                  template_head();
                                  {
                                    bool synPredMatched61 = false;
                                    if (((_tokenSet_12.member(LA(1))) &&
                                         (_tokenSet_18.member(LA(2))))) {
                                      int _m61 = mark();
                                      synPredMatched61 = true;
                                      inputState->guessing++;
                                      try {
                                        {
                                          declaration_specifiers();
                                          {
                                            switch (LA(1)) {
                                              case ID:
                                              case LITERAL__stdcall:
                                              case LITERAL___stdcall:
                                              case LPAREN:
                                              case OPERATOR:
                                              case LITERAL_this:
                                              case LITERAL_true:
                                              case LITERAL_false:
                                              case TILDE:
                                              case STAR:
                                              case AMPERSAND:
                                              case SCOPE:
                                              case LITERAL__cdecl:
                                              case LITERAL___cdecl:
                                              case LITERAL__near:
                                              case LITERAL___near:
                                              case LITERAL__far:
                                              case LITERAL___far:
                                              case LITERAL___interrupt:
                                              case LITERAL_pascal:
                                              case LITERAL__pascal:
                                              case LITERAL___pascal: {
                                                init_declarator_list();
                                                break;
                                              }
                                              case SEMICOLON: {
                                                break;
                                              }
                                              default: {
                                                throw ANTLR_USE_NAMESPACE(antlr)
                                                    NoViableAltException(
                                                        LT(1), getFilename());
                                              }
                                            }
                                          }
                                          match(SEMICOLON);
                                          if (inputState->guessing == 0) {
#line 505 "CPP_parser.g"
                                            end_of_stmt();
#line 1151 "CPPParser.cpp"
                                          }
                                        }
                                      } catch (ANTLR_USE_NAMESPACE(antlr)
                                                   RecognitionException& pe) {
                                        synPredMatched61 = false;
                                      }
                                      rewind(_m61);
                                      inputState->guessing--;
                                    }
                                    if (synPredMatched61) {
                                      if (inputState->guessing == 0) {
#line 506 "CPP_parser.g"
                                        if (statementTrace >= 1) {
                                          printf(
                                              "%d external_declaration "
                                              "Templated class forward "
                                              "declaration\n",
                                              LT(1)->getLine());
                                        }

#line 1167 "CPPParser.cpp"
                                      }
                                      declaration_specifiers();
                                      {
                                        switch (LA(1)) {
                                          case ID:
                                          case LITERAL__stdcall:
                                          case LITERAL___stdcall:
                                          case LPAREN:
                                          case OPERATOR:
                                          case LITERAL_this:
                                          case LITERAL_true:
                                          case LITERAL_false:
                                          case TILDE:
                                          case STAR:
                                          case AMPERSAND:
                                          case SCOPE:
                                          case LITERAL__cdecl:
                                          case LITERAL___cdecl:
                                          case LITERAL__near:
                                          case LITERAL___near:
                                          case LITERAL__far:
                                          case LITERAL___far:
                                          case LITERAL___interrupt:
                                          case LITERAL_pascal:
                                          case LITERAL__pascal:
                                          case LITERAL___pascal: {
                                            init_declarator_list();
                                            break;
                                          }
                                          case SEMICOLON: {
                                            break;
                                          }
                                          default: {
                                            throw ANTLR_USE_NAMESPACE(antlr)
                                                NoViableAltException(
                                                    LT(1), getFilename());
                                          }
                                        }
                                      }
                                      match(SEMICOLON);
                                      if (inputState->guessing == 0) {
#line 509 "CPP_parser.g"
                                        end_of_stmt();
#line 1212 "CPPParser.cpp"
                                      }
                                    } else {
                                      bool synPredMatched64 = false;
                                      if (((_tokenSet_2.member(LA(1))) &&
                                           (_tokenSet_3.member(LA(2))))) {
                                        int _m64 = mark();
                                        synPredMatched64 = true;
                                        inputState->guessing++;
                                        try {
                                          {
                                            declaration_specifiers();
                                            function_declarator(0);
                                            match(SEMICOLON);
                                          }
                                        } catch (ANTLR_USE_NAMESPACE(antlr)
                                                     RecognitionException& pe) {
                                          synPredMatched64 = false;
                                        }
                                        rewind(_m64);
                                        inputState->guessing--;
                                      }
                                      if (synPredMatched64) {
                                        if (inputState->guessing == 0) {
#line 513 "CPP_parser.g"
                                          if (statementTrace >= 1) {
                                            printf(
                                                "%d external_declaration "
                                                "Templated function "
                                                "declaration\n",
                                                LT(1)->getLine());
                                          }

#line 1240 "CPPParser.cpp"
                                        }
                                        declaration();
                                      } else {
                                        bool synPredMatched66 = false;
                                        if (((_tokenSet_14.member(LA(1))) &&
                                             (_tokenSet_15.member(LA(2))))) {
                                          int _m66 = mark();
                                          synPredMatched66 = true;
                                          inputState->guessing++;
                                          try {
                                            {
                                              declaration_specifiers();
                                              function_declarator(1);
                                              match(LCURLY);
                                            }
                                          } catch (ANTLR_USE_NAMESPACE(
                                              antlr) RecognitionException& pe) {
                                            synPredMatched66 = false;
                                          }
                                          rewind(_m66);
                                          inputState->guessing--;
                                        }
                                        if (synPredMatched66) {
                                          if (inputState->guessing == 0) {
#line 520 "CPP_parser.g"
                                            if (statementTrace >= 1) {
                                              printf(
                                                  "%d external_declaration_10c "
                                                  "Templated function "
                                                  "definition\n",
                                                  LT(1)->getLine());
                                            }

#line 1269 "CPPParser.cpp"
                                          }
                                          function_definition();
                                        } else {
                                          bool synPredMatched68 = false;
                                          if (((_tokenSet_8.member(LA(1))) &&
                                               (_tokenSet_9.member(LA(2))))) {
                                            int _m68 = mark();
                                            synPredMatched68 = true;
                                            inputState->guessing++;
                                            try {
                                              {
                                                ctor_decl_spec();
                                                if (!(qualifiedItemIsOneOf(
                                                        qiCtor))) {
                                                  throw ANTLR_USE_NAMESPACE(
                                                      antlr)
                                                      SemanticException(
                                                          "qualifiedItemIsOneOf"
                                                          "(qiCtor)");
                                                }
                                              }
                                            } catch (
                                                ANTLR_USE_NAMESPACE(antlr)
                                                    RecognitionException& pe) {
                                              synPredMatched68 = false;
                                            }
                                            rewind(_m68);
                                            inputState->guessing--;
                                          }
                                          if (synPredMatched68) {
                                            if (inputState->guessing == 0) {
#line 531 "CPP_parser.g"
                                              if (statementTrace >= 1) {
                                                printf(
                                                    "%d external_declaration "
                                                    "Templated constructor "
                                                    "definition\n",
                                                    LT(1)->getLine());
                                              }

#line 1298 "CPPParser.cpp"
                                            }
                                            ctor_definition();
                                          } else {
                                            throw ANTLR_USE_NAMESPACE(antlr)
                                                NoViableAltException(
                                                    LT(1), getFilename());
                                          }
                                        }
                                      }
                                    }
                                  }
                                  if (inputState->guessing == 0) {
#line 536 "CPP_parser.g"
                                    endTemplateDeclaration();
#line 1310 "CPPParser.cpp"
                                  }
                                } else if ((_tokenSet_2.member(LA(1))) &&
                                           (_tokenSet_3.member(LA(2)))) {
                                  if (inputState->guessing == 0) {
#line 545 "CPP_parser.g"
                                    if (statementTrace >= 1) {
                                      printf(
                                          "%d external_declaration "
                                          "Declaration\n",
                                          LT(1)->getLine());
                                    }

#line 1319 "CPPParser.cpp"
                                  }
                                  declaration();
                                } else {
                                  throw ANTLR_USE_NAMESPACE(antlr)
                                      NoViableAltException(LT(1),
                                                           getFilename());
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_19);
    } else {
      throw;
    }
  }
}

CPPParser::TypeSpecifier CPPParser::class_specifier() {
#line 1016 "CPP_parser.g"
  CPPParser::TypeSpecifier ts = tsInvalid;
#line 1342 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_class: {
          match(LITERAL_class);
          if (inputState->guessing == 0) {
#line 1018 "CPP_parser.g"
            ts = tsCLASS;
#line 1353 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_struct: {
          match(LITERAL_struct);
          if (inputState->guessing == 0) {
#line 1019 "CPP_parser.g"
            ts = tsSTRUCT;
#line 1363 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_union: {
          match(LITERAL_union);
          if (inputState->guessing == 0) {
#line 1020 "CPP_parser.g"
            ts = tsUNION;
#line 1373 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_12);
    } else {
      throw;
    }
  }
  return ts;
}

void CPPParser::class_decl_or_def(FunctionSpecifier fs) {
#line 1042 "CPP_parser.g"
  char* saveClass;
  char* id;
  TypeSpecifier ts = tsInvalid;  // Available for use

#line 1403 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_class: {
          match(LITERAL_class);
          if (inputState->guessing == 0) {
#line 1048 "CPP_parser.g"
            ts = tsCLASS;
#line 1414 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_struct: {
          match(LITERAL_struct);
          if (inputState->guessing == 0) {
#line 1049 "CPP_parser.g"
            ts = tsSTRUCT;
#line 1424 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_union: {
          match(LITERAL_union);
          if (inputState->guessing == 0) {
#line 1050 "CPP_parser.g"
            ts = tsUNION;
#line 1434 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    class_prefix();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == LITERAL_GFIGNORE)) {
          match(LITERAL_GFIGNORE);
          match(LPAREN);
          expression();
          match(RPAREN);
          if (inputState->guessing == 0) {
#line 1053 "CPP_parser.g"
#line 1454 "CPPParser.cpp"
          }
        } else {
          goto _loop208;
        }
      }
    _loop208:;
    }  // ( ... )*
    {
      switch (LA(1)) {
        case ID:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case SCOPE: {
          id = qualified_id();
          {
            switch (LA(1)) {
              case SEMICOLON:
              case ID:
              case LITERAL__stdcall:
              case LITERAL___stdcall:
              case LPAREN:
              case OPERATOR:
              case LITERAL_this:
              case LITERAL_true:
              case LITERAL_false:
              case TILDE:
              case STAR:
              case AMPERSAND:
              case SCOPE:
              case LITERAL__cdecl:
              case LITERAL___cdecl:
              case LITERAL__near:
              case LITERAL___near:
              case LITERAL__far:
              case LITERAL___far:
              case LITERAL___interrupt:
              case LITERAL_pascal:
              case LITERAL__pascal:
              case LITERAL___pascal: {
                if (inputState->guessing == 0) {
#line 1058 "CPP_parser.g"
                  classForwardDeclaration(ts, fs, id);
#line 1503 "CPPParser.cpp"
                }
                break;
              }
              case LCURLY:
              case COLON: {
                if (inputState->guessing == 0) {
#line 1060 "CPP_parser.g"
                  saveClass = enclosingClass;
                  enclosingClass = symbols->strdup(id);

#line 1515 "CPPParser.cpp"
                }
                {
                  switch (LA(1)) {
                    case COLON: {
                      base_clause();
                      break;
                    }
                    case LCURLY: {
                      break;
                    }
                    default: {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }
                }
                match(LCURLY);
                if (inputState->guessing == 0) {
#line 1065 "CPP_parser.g"
                  beginClassDefinition(ts, id);
#line 1538 "CPPParser.cpp"
                }
                {  // ( ... )*
                  for (;;) {
                    if ((_tokenSet_20.member(LA(1)))) {
                      member_declaration();
                    } else {
                      goto _loop215;
                    }
                  }
                _loop215:;
                }  // ( ... )*
                if (inputState->guessing == 0) {
#line 1067 "CPP_parser.g"
                  endClassDefinition();
#line 1555 "CPPParser.cpp"
                }
                match(RCURLY);
                if (inputState->guessing == 0) {
#line 1069 "CPP_parser.g"
                  enclosingClass = saveClass;
#line 1561 "CPPParser.cpp"
                }
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case LCURLY: {
          match(LCURLY);
          if (inputState->guessing == 0) {
#line 1073 "CPP_parser.g"
            saveClass = enclosingClass;
            enclosingClass = (char*)"__anonymous";
#line 1579 "CPPParser.cpp"
          }
          if (inputState->guessing == 0) {
#line 1074 "CPP_parser.g"
            beginClassDefinition(ts, "anonymous");
#line 1584 "CPPParser.cpp"
          }
          {  // ( ... )*
            for (;;) {
              if ((_tokenSet_20.member(LA(1)))) {
                member_declaration();
              } else {
                goto _loop217;
              }
            }
          _loop217:;
          }  // ( ... )*
          if (inputState->guessing == 0) {
#line 1076 "CPP_parser.g"
            endClassDefinition();
#line 1601 "CPPParser.cpp"
          }
          match(RCURLY);
          if (inputState->guessing == 0) {
#line 1078 "CPP_parser.g"
            enclosingClass = saveClass;
#line 1607 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_21);
    } else {
      throw;
    }
  }
}

void CPPParser::init_declarator_list() {
  try {  // for error handling
    init_declarator();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          init_declarator();
        } else {
          goto _loop242;
        }
      }
    _loop242:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_22);
    } else {
      throw;
    }
  }
}

void CPPParser::enum_specifier() {
#line 1108 "CPP_parser.g"
  char* id;
#line 1659 "CPPParser.cpp"

  try {  // for error handling
    match(LITERAL_enum);
    {
      switch (LA(1)) {
        case LCURLY: {
          match(LCURLY);
          enumerator_list();
          match(RCURLY);
          break;
        }
        case ID:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case SCOPE: {
          id = qualified_id();
          if (inputState->guessing == 0) {
#line 1116 "CPP_parser.g"
            beginEnumDefinition(id);
#line 1683 "CPPParser.cpp"
          }
          {
            switch (LA(1)) {
              case LCURLY: {
                match(LCURLY);
                enumerator_list();
                match(RCURLY);
                break;
              }
              case SEMICOLON:
              case ID:
              case COLON:
              case LITERAL__stdcall:
              case LITERAL___stdcall:
              case LPAREN:
              case OPERATOR:
              case LITERAL_this:
              case LITERAL_true:
              case LITERAL_false:
              case TILDE:
              case STAR:
              case AMPERSAND:
              case SCOPE:
              case LITERAL__cdecl:
              case LITERAL___cdecl:
              case LITERAL__near:
              case LITERAL___near:
              case LITERAL__far:
              case LITERAL___far:
              case LITERAL___interrupt:
              case LITERAL_pascal:
              case LITERAL__pascal:
              case LITERAL___pascal: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          if (inputState->guessing == 0) {
#line 1118 "CPP_parser.g"
            endEnumDefinition();
#line 1730 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_23);
    } else {
      throw;
    }
  }
}

void CPPParser::declaration_specifiers() {
  ANTLR_USE_NAMESPACE(antlr)
  RefToken gfArr = ANTLR_USE_NAMESPACE(antlr) nullToken;
  ANTLR_USE_NAMESPACE(antlr)
  RefToken gfArrList = ANTLR_USE_NAMESPACE(antlr) nullToken;
  ANTLR_USE_NAMESPACE(antlr)
  RefToken gfArrElem = ANTLR_USE_NAMESPACE(antlr) nullToken;
#line 885 "CPP_parser.g"
  // Locals
  bool td = false;              // For typedef
  bool fd = false;              // For friend
  StorageClass sc = scInvalid;  // auto,register,static,extern,mutable
  TypeQualifier tq =
      tqInvalid;  // const,volatile  // aka cv_qualifier See type_qualifier
  TypeSpecifier ts = tsInvalid;  // char,int,double, etc., class,struct,union
  FunctionSpecifier fs = fsInvalid;  // inline,virtual,explicit

#line 1764 "CPPParser.cpp"

  try {  // for error handling
    if (inputState->guessing == 0) {
#line 895 "CPP_parser.g"

      // Global flags to allow for nested declarations
      _td = false;      // For typedef
      _fd = false;      // For friend
      _sc = scInvalid;  // For StorageClass    //
                        // auto,register,static,extern,mutable
      _tq = tqInvalid;  // For TypeQualifier  // aka cv_qualifier See
                        // type_qualifier
      _ts = tsInvalid;  // For TypeSpecifier
      _fs = fsInvalid;  // For FunctionSpecifier  // inline,virtual,explicit

#line 1779 "CPPParser.cpp"
    }
    {
      {  // ( ... )*
        for (;;) {
          switch (LA(1)) {
            case LITERAL_typedef: {
              match(LITERAL_typedef);
              if (inputState->guessing == 0) {
#line 906 "CPP_parser.g"
                td = true;
#line 1791 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_friend: {
              match(LITERAL_friend);
              if (inputState->guessing == 0) {
#line 907 "CPP_parser.g"
                fd = true;
#line 1801 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_extern:
            case LITERAL_auto:
            case LITERAL_register:
            case LITERAL_static:
            case LITERAL_mutable: {
              sc = storage_class_specifier();
              break;
            }
            case LITERAL_const:
            case LITERAL___const:
            case LITERAL_volatile:
            case LITERAL___volatile__: {
              tq = type_qualifier();
              break;
            }
            case LITERAL_struct:
            case LITERAL_union:
            case LITERAL_class: {
              ts = class_specifier();
              break;
            }
            case LITERAL_enum: {
              match(LITERAL_enum);
              break;
            }
            case LITERAL_inline:
            case LITERAL__inline:
            case LITERAL___inline:
            case LITERAL_virtual:
            case LITERAL_explicit: {
              fs = function_specifier();
              break;
            }
            case LITERAL__stdcall:
            case LITERAL___stdcall: {
              {
                switch (LA(1)) {
                  case LITERAL__stdcall: {
                    match(LITERAL__stdcall);
                    break;
                  }
                  case LITERAL___stdcall: {
                    match(LITERAL___stdcall);
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
              break;
            }
            case LITERAL_GFEXCLUDE: {
              match(LITERAL_GFEXCLUDE);
              if (inputState->guessing == 0) {
#line 914 "CPP_parser.g"
                tq |= tqGFEXCLUDE;
                _tq |= tqGFEXCLUDE;
#line 1872 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_GFINCLUDE: {
              match(LITERAL_GFINCLUDE);
              if (inputState->guessing == 0) {
#line 915 "CPP_parser.g"
                tq |= tqGFINCLUDE;
                _tq |= tqGFINCLUDE;
#line 1882 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_GFID: {
              match(LITERAL_GFID);
              if (inputState->guessing == 0) {
#line 916 "CPP_parser.g"
                tq |= tqGFID;
                _tq |= tqGFID;
#line 1892 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_GFUNREAD: {
              match(LITERAL_GFUNREAD);
              if (inputState->guessing == 0) {
#line 917 "CPP_parser.g"
                tq |= tqGFUNREAD;
                _tq |= tqGFUNREAD;
#line 1902 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_GFARRAYSIZE: {
              match(LITERAL_GFARRAYSIZE);
              match(LPAREN);
              gfArr = LT(1);
              match(ID);
              match(RPAREN);
              if (inputState->guessing == 0) {
#line 918 "CPP_parser.g"
                gfArraySize(gfArr->getText().data());
#line 1916 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_GFARRAYSIZES: {
              match(LITERAL_GFARRAYSIZES);
              match(LPAREN);
              gfArrList = LT(1);
              match(StringLiteral);
              match(RPAREN);
              if (inputState->guessing == 0) {
#line 919 "CPP_parser.g"
                gfArraySize(gfArrList->getText().data());
#line 1930 "CPPParser.cpp"
              }
              break;
            }
            case LITERAL_GFARRAYELEMSIZE: {
              match(LITERAL_GFARRAYELEMSIZE);
              match(LPAREN);
              gfArrElem = LT(1);
              match(ID);
              match(RPAREN);
              if (inputState->guessing == 0) {
#line 920 "CPP_parser.g"
                gfArrayElemSize(gfArrElem->getText().data());
#line 1944 "CPPParser.cpp"
              }
              break;
            }
            default: { goto _loop174; }
          }
        }
      _loop174:;
      }  // ( ... )*
      ts = type_specifier();
    }
    if (inputState->guessing == 0) {
#line 924 "CPP_parser.g"
      declarationSpecifier(td, fd, sc, tq, ts, fs);
#line 1961 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_24);
    } else {
      throw;
    }
  }
}

void CPPParser::function_declarator(int definition) {
  try {  // for error handling
    bool synPredMatched298 = false;
    if (((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2))))) {
      int _m298 = mark();
      synPredMatched298 = true;
      inputState->guessing++;
      try {
        { ptr_operator(); }
      } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
        synPredMatched298 = false;
      }
      rewind(_m298);
      inputState->guessing--;
    }
    if (synPredMatched298) {
      ptr_operator();
      function_declarator(definition);
    } else if ((_tokenSet_27.member(LA(1))) && (_tokenSet_28.member(LA(2)))) {
      function_direct_declarator(definition);
    } else {
      throw ANTLR_USE_NAMESPACE(antlr)
          NoViableAltException(LT(1), getFilename());
    }

  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_29);
    } else {
      throw;
    }
  }
}

void CPPParser::declaration() {
  try {  // for error handling
    bool synPredMatched159 = false;
    if (((LA(1) == LITERAL_extern) && (LA(2) == StringLiteral))) {
      int _m159 = mark();
      synPredMatched159 = true;
      inputState->guessing++;
      try {
        {
          match(LITERAL_extern);
          match(StringLiteral);
        }
      } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
        synPredMatched159 = false;
      }
      rewind(_m159);
      inputState->guessing--;
    }
    if (synPredMatched159) {
      linkage_specification();
    } else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
      if (inputState->guessing == 0) {
#line 853 "CPP_parser.g"
        beginDeclaration();
#line 2044 "CPPParser.cpp"
      }
      declaration_specifiers();
      {
        switch (LA(1)) {
          case ID:
          case LITERAL__stdcall:
          case LITERAL___stdcall:
          case LPAREN:
          case OPERATOR:
          case LITERAL_this:
          case LITERAL_true:
          case LITERAL_false:
          case TILDE:
          case STAR:
          case AMPERSAND:
          case SCOPE:
          case LITERAL__cdecl:
          case LITERAL___cdecl:
          case LITERAL__near:
          case LITERAL___near:
          case LITERAL__far:
          case LITERAL___far:
          case LITERAL___interrupt:
          case LITERAL_pascal:
          case LITERAL__pascal:
          case LITERAL___pascal: {
            init_declarator_list();
            break;
          }
          case SEMICOLON: {
            break;
          }
          default: {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
      }
      match(SEMICOLON);
      if (inputState->guessing == 0) {
#line 854 "CPP_parser.g"
        end_of_stmt();
#line 2089 "CPPParser.cpp"
      }
      if (inputState->guessing == 0) {
#line 855 "CPP_parser.g"
        endDeclaration();
#line 2094 "CPPParser.cpp"
      }
    } else if ((LA(1) == LITERAL_using)) {
      using_statement();
    } else {
      throw ANTLR_USE_NAMESPACE(antlr)
          NoViableAltException(LT(1), getFilename());
    }

  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

void CPPParser::template_head() {
  try {  // for error handling
    match(LITERAL_template);
    match(LESSTHAN);
    template_parameter_list();
    match(GREATERTHAN);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_31);
    } else {
      throw;
    }
  }
}

CPPParser::FunctionSpecifier CPPParser::function_specifier() {
#line 937 "CPP_parser.g"
  CPPParser::FunctionSpecifier fs = fsInvalid;
#line 2136 "CPPParser.cpp"

  try {  // for error handling
    switch (LA(1)) {
      case LITERAL_inline:
      case LITERAL__inline:
      case LITERAL___inline: {
        {
          switch (LA(1)) {
            case LITERAL_inline: {
              match(LITERAL_inline);
              break;
            }
            case LITERAL__inline: {
              match(LITERAL__inline);
              break;
            }
            case LITERAL___inline: {
              match(LITERAL___inline);
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
        if (inputState->guessing == 0) {
#line 938 "CPP_parser.g"
          fs = fsINLINE;
#line 2170 "CPPParser.cpp"
        }
        break;
      }
      case LITERAL_virtual: {
        match(LITERAL_virtual);
        if (inputState->guessing == 0) {
#line 939 "CPP_parser.g"
          fs = fsVIRTUAL;
#line 2180 "CPPParser.cpp"
        }
        break;
      }
      case LITERAL_explicit: {
        match(LITERAL_explicit);
        if (inputState->guessing == 0) {
#line 940 "CPP_parser.g"
          fs = fsEXPLICIT;
#line 2190 "CPPParser.cpp"
        }
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_14);
    } else {
      throw;
    }
  }
  return fs;
}

void CPPParser::dtor_head(int definition) {
  try {  // for error handling
    dtor_decl_spec();
    dtor_declarator(definition);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_32);
    } else {
      throw;
    }
  }
}

void CPPParser::dtor_body() {
  try {  // for error handling
    compound_statement();
    if (inputState->guessing == 0) {
#line 1476 "CPP_parser.g"
      endDestructorDefinition();
#line 2236 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

void CPPParser::ctor_decl_spec() {
  try {  // for error handling
    {    // ( ... )*
      for (;;) {
        switch (LA(1)) {
          case LITERAL_inline:
          case LITERAL__inline:
          case LITERAL___inline: {
            {
              switch (LA(1)) {
                case LITERAL_inline: {
                  match(LITERAL_inline);
                  break;
                }
                case LITERAL__inline: {
                  match(LITERAL__inline);
                  break;
                }
                case LITERAL___inline: {
                  match(LITERAL___inline);
                  break;
                }
                default: {
                  throw ANTLR_USE_NAMESPACE(antlr)
                      NoViableAltException(LT(1), getFilename());
                }
              }
            }
            break;
          }
          case LITERAL_explicit: {
            match(LITERAL_explicit);
            break;
          }
          default: { goto _loop311; }
        }
      }
    _loop311:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_33);
    } else {
      throw;
    }
  }
}

void CPPParser::ctor_definition() {
  try {  // for error handling
    ctor_head();
    ctor_body();
    if (inputState->guessing == 0) {
#line 1385 "CPP_parser.g"
      endConstructorDefinition();
#line 2316 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

char* CPPParser::scope_override() {
#line 2226 "CPP_parser.g"
  char* s = NULL;
#line 2332 "CPPParser.cpp"
  ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken;
#line 2226 "CPP_parser.g"

  static char sitem[CPPParser_MaxQualifiedItemSize + 1];
  sitem[0] = '\0';

#line 2339 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case SCOPE: {
          match(SCOPE);
          if (inputState->guessing == 0) {
#line 2232 "CPP_parser.g"
            strcat(sitem, "::");
#line 2350 "CPPParser.cpp"
          }
          break;
        }
        case ID:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case TILDE:
        case STAR: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    {  // ( ... )*
      for (;;) {
        if (((LA(1) == ID) && (LA(2) == LESSTHAN || LA(2) == SCOPE)) &&
            (scopedItem())) {
          id = LT(1);
          match(ID);
          {
            switch (LA(1)) {
              case LESSTHAN: {
                match(LESSTHAN);
                template_argument_list();
                match(GREATERTHAN);
                break;
              }
              case SCOPE: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          match(SCOPE);
          {
            switch (LA(1)) {
              case LITERAL_template: {
                match(LITERAL_template);
                break;
              }
              case ID:
              case OPERATOR:
              case LITERAL_this:
              case LITERAL_true:
              case LITERAL_false:
              case TILDE:
              case STAR: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          if (inputState->guessing == 0) {
#line 2238 "CPP_parser.g"

            CPPSymbol* cs = (CPPSymbol*)symbols->lookup((id->getText()).data());
            strcat(sitem, (id->getText()).data());
            strcat(sitem, "::");

#line 2425 "CPPParser.cpp"
          }
        } else {
          goto _loop587;
        }
      }
    _loop587:;
    }  // ( ... )*
    if (inputState->guessing == 0) {
#line 2244 "CPP_parser.g"
      s = sitem;
#line 2438 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_34);
    } else {
      throw;
    }
  }
  return s;
}

void CPPParser::conversion_function_decl_or_def() {
#line 1302 "CPP_parser.g"
  CPPParser::TypeQualifier tq;
#line 2455 "CPPParser.cpp"

  try {  // for error handling
    match(OPERATOR);
    declaration_specifiers();
    {
      switch (LA(1)) {
        case STAR: {
          match(STAR);
          break;
        }
        case AMPERSAND: {
          match(AMPERSAND);
          break;
        }
        case LESSTHAN:
        case LPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    {
      switch (LA(1)) {
        case LESSTHAN: {
          match(LESSTHAN);
          template_parameter_list();
          match(GREATERTHAN);
          break;
        }
        case LPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(LPAREN);
    {
      switch (LA(1)) {
        case LITERAL_typedef:
        case LITERAL_enum:
        case ID:
        case LITERAL_inline:
        case LITERAL_friend:
        case LITERAL_extern:
        case LITERAL_struct:
        case LITERAL_union:
        case LITERAL_class:
        case LITERAL__stdcall:
        case LITERAL___stdcall:
        case LITERAL_GFEXCLUDE:
        case LITERAL_GFINCLUDE:
        case LITERAL_GFID:
        case LITERAL_GFUNREAD:
        case LITERAL_GFARRAYSIZE:
        case LPAREN:
        case LITERAL_GFARRAYSIZES:
        case LITERAL_GFARRAYELEMSIZE:
        case LITERAL_auto:
        case LITERAL_register:
        case LITERAL_static:
        case LITERAL_mutable:
        case LITERAL__inline:
        case LITERAL___inline:
        case LITERAL_virtual:
        case LITERAL_explicit:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case LITERAL_const:
        case LITERAL___const:
        case LITERAL_volatile:
        case LITERAL___volatile__:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case ELLIPSIS:
        case SCOPE:
        case LITERAL__cdecl:
        case LITERAL___cdecl:
        case LITERAL__near:
        case LITERAL___near:
        case LITERAL__far:
        case LITERAL___far:
        case LITERAL___interrupt:
        case LITERAL_pascal:
        case LITERAL__pascal:
        case LITERAL___pascal: {
          parameter_list();
          break;
        }
        case RPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(RPAREN);
    {  // ( ... )*
      for (;;) {
        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) {
          tq = type_qualifier();
        } else {
          goto _loop293;
        }
      }
    _loop293:;
    }  // ( ... )*
    {
      switch (LA(1)) {
        case LITERAL_throw: {
          exception_specification();
          break;
        }
        case SEMICOLON:
        case LCURLY: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    {
      switch (LA(1)) {
        case LCURLY: {
          compound_statement();
          break;
        }
        case SEMICOLON: {
          match(SEMICOLON);
          if (inputState->guessing == 0) {
#line 1311 "CPP_parser.g"
            end_of_stmt();
#line 2645 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

void CPPParser::function_definition() {
  try {  // for error handling
    if (inputState->guessing == 0) {
#line 822 "CPP_parser.g"

      beginFunctionDefinition();

#line 2674 "CPPParser.cpp"
    }
    {
      if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) &&
          ((!(LA(1) == SCOPE || LA(1) == ID) ||
            qualifiedItemIsOneOf(qiType | qiCtor)))) {
        declaration_specifiers();
        function_declarator(1);
        {
          if ((_tokenSet_35.member(LA(1))) && (_tokenSet_36.member(LA(2)))) {
            {  // ( ... )*
              for (;;) {
                if ((_tokenSet_2.member(LA(1)))) {
                  declaration();
                } else {
                  goto _loop153;
                }
              }
            _loop153:;
            }  // ( ... )*
            if (inputState->guessing == 0) {
#line 831 "CPP_parser.g"
              in_parameter_list = false;
#line 2697 "CPPParser.cpp"
            }
          } else if ((LA(1) == LCURLY) && (_tokenSet_37.member(LA(2)))) {
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        compound_statement();
      } else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_39.member(LA(2)))) {
        function_declarator(1);
        {
          if ((_tokenSet_35.member(LA(1))) && (_tokenSet_36.member(LA(2)))) {
            {  // ( ... )*
              for (;;) {
                if ((_tokenSet_2.member(LA(1)))) {
                  declaration();
                } else {
                  goto _loop156;
                }
              }
            _loop156:;
            }  // ( ... )*
            if (inputState->guessing == 0) {
#line 840 "CPP_parser.g"
              in_parameter_list = false;
#line 2728 "CPPParser.cpp"
            }
          } else if ((LA(1) == LCURLY) && (_tokenSet_37.member(LA(2)))) {
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        compound_statement();
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
    if (inputState->guessing == 0) {
#line 844 "CPP_parser.g"
      endFunctionDefinition();
#line 2748 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

void CPPParser::namespace_definition() {
  ANTLR_USE_NAMESPACE(antlr) RefToken ns = ANTLR_USE_NAMESPACE(antlr) nullToken;

  try {  // for error handling
    {
      switch (LA(1)) {
        case ID: {
          ns = LT(1);
          match(ID);
          if (inputState->guessing == 0) {
#line 568 "CPP_parser.g"
            declaratorID((ns->getText()).data(), qiNamespace);
#line 2774 "CPPParser.cpp"
          }
          break;
        }
        case LCURLY: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(LCURLY);
    if (inputState->guessing == 0) {
#line 570 "CPP_parser.g"
      enterNewLocalScope();
#line 2792 "CPPParser.cpp"
    }
    {  // ( ... )*
      for (;;) {
        if ((_tokenSet_0.member(LA(1)))) {
          external_declaration();
        } else {
          goto _loop72;
        }
      }
    _loop72:;
    }  // ( ... )*
    if (inputState->guessing == 0) {
#line 572 "CPP_parser.g"
      exitNamespaceScope();
      exitLocalScope();
#line 2809 "CPPParser.cpp"
    }
    match(RCURLY);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_19);
    } else {
      throw;
    }
  }
}

void CPPParser::namespace_alias_definition() {
  ANTLR_USE_NAMESPACE(antlr)
  RefToken ns2 = ANTLR_USE_NAMESPACE(antlr) nullToken;
#line 577 "CPP_parser.g"
  char* qid;
#line 2827 "CPPParser.cpp"

  try {  // for error handling
    match(LITERAL_namespace);
    ns2 = LT(1);
    match(ID);
    if (inputState->guessing == 0) {
#line 581 "CPP_parser.g"
      declaratorID((ns2->getText()).data(), qiNamespace);
#line 2836 "CPPParser.cpp"
    }
    match(ASSIGNEQUAL);
    qid = qualified_id();
    match(SEMICOLON);
    if (inputState->guessing == 0) {
#line 582 "CPP_parser.g"
      end_of_stmt();
#line 2844 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

char* CPPParser::qualified_id() {
#line 1143 "CPP_parser.g"
  char* q = NULL;
#line 2860 "CPPParser.cpp"
  ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken;
#line 1143 "CPP_parser.g"

  char* so = NULL;
  static char qitem[CPPParser_MaxQualifiedItemSize + 1];

#line 2867 "CPPParser.cpp"

  try {  // for error handling
    so = scope_override();
    if (inputState->guessing == 0) {
#line 1150 "CPP_parser.g"
      strcpy(qitem, so);
#line 2874 "CPPParser.cpp"
    }
    {
      switch (LA(1)) {
        case ID: {
          id = LT(1);
          match(ID);
          {
            switch (LA(1)) {
              case LESSTHAN: {
                match(LESSTHAN);
                template_argument_list();
                match(GREATERTHAN);
                break;
              }
              case GREATERTHAN:
              case SEMICOLON:
              case ID:
              case LCURLY:
              case ASSIGNEQUAL:
              case COLON:
              case LITERAL__stdcall:
              case LITERAL___stdcall:
              case LPAREN:
              case RPAREN:
              case COMMA:
              case OPERATOR:
              case LITERAL_this:
              case LITERAL_true:
              case LITERAL_false:
              case LSQUARE:
              case TILDE:
              case STAR:
              case AMPERSAND:
              case ELLIPSIS:
              case SCOPE:
              case LITERAL__cdecl:
              case LITERAL___cdecl:
              case LITERAL__near:
              case LITERAL___near:
              case LITERAL__far:
              case LITERAL___far:
              case LITERAL___interrupt:
              case LITERAL_pascal:
              case LITERAL__pascal:
              case LITERAL___pascal: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          if (inputState->guessing == 0) {
#line 1155 "CPP_parser.g"
            strcat(qitem, (id->getText()).data());
#line 2934 "CPPParser.cpp"
          }
          break;
        }
        case OPERATOR: {
          match(OPERATOR);
          optor();
          if (inputState->guessing == 0) {
#line 1158 "CPP_parser.g"
            strcat(qitem, "operator");
            strcat(qitem, "NYI");
#line 2945 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_this: {
          match(LITERAL_this);
          break;
        }
        case LITERAL_true:
        case LITERAL_false: {
          {
            switch (LA(1)) {
              case LITERAL_true: {
                match(LITERAL_true);
                break;
              }
              case LITERAL_false: {
                match(LITERAL_false);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    if (inputState->guessing == 0) {
#line 1164 "CPP_parser.g"
      q = qitem;
#line 2986 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_41);
    } else {
      throw;
    }
  }
  return q;
}

void CPPParser::member_declaration() {
#line 585 "CPP_parser.g"
  char* q;
  FunctionSpecifier fs = fsInvalid;  // inline,virtual,explicit

#line 3005 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_public:
        case LITERAL_protected:
        case LITERAL_private: {
          if (inputState->guessing == 0) {
#line 799 "CPP_parser.g"
            if (statementTrace >= 1) {
              printf("%d member_declaration Access specifier\n",
                     LT(1)->getLine());
            }

#line 3019 "CPPParser.cpp"
          }
          access_specifier();
          match(COLON);
          break;
        }
        case SEMICOLON: {
          if (inputState->guessing == 0) {
#line 805 "CPP_parser.g"
            if (statementTrace >= 1) {
              printf("%d member_declaration Semicolon\n", LT(1)->getLine());
            }

#line 3032 "CPPParser.cpp"
          }
          match(SEMICOLON);
          if (inputState->guessing == 0) {
#line 808 "CPP_parser.g"
            end_of_stmt();
#line 3038 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_antlrTrace_on: {
          match(LITERAL_antlrTrace_on);
          if (inputState->guessing == 0) {
#line 812 "CPP_parser.g"
            antlrTrace(true);
#line 3048 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_antlrTrace_off: {
          match(LITERAL_antlrTrace_off);
          if (inputState->guessing == 0) {
#line 815 "CPP_parser.g"
            antlrTrace(false);
#line 3058 "CPPParser.cpp"
          }
          break;
        }
        default:
          bool synPredMatched77 = false;
          if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) {
            int _m77 = mark();
            synPredMatched77 = true;
            inputState->guessing++;
            try {
              {
                match(LITERAL_template);
                match(LESSTHAN);
                match(GREATERTHAN);
              }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched77 = false;
            }
            rewind(_m77);
            inputState->guessing--;
          }
          if (synPredMatched77) {
            if (inputState->guessing == 0) {
#line 593 "CPP_parser.g"
              if (statementTrace >= 1) {
                printf(
                    "%d member_declaration Template explicit-specialisation\n",
                    LT(1)->getLine());
              }

#line 3087 "CPPParser.cpp"
            }
            match(LITERAL_template);
            match(LESSTHAN);
            match(GREATERTHAN);
            member_declaration();
          } else {
            bool synPredMatched79 = false;
            if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) {
              int _m79 = mark();
              synPredMatched79 = true;
              inputState->guessing++;
              try {
                { match(LITERAL_typedef); }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched79 = false;
              }
              rewind(_m79);
              inputState->guessing--;
            }
            if (synPredMatched79) {
              {
                bool synPredMatched82 = false;
                if (((LA(1) == LITERAL_typedef) &&
                     ((LA(2) >= LITERAL_struct && LA(2) <= LITERAL_class)))) {
                  int _m82 = mark();
                  synPredMatched82 = true;
                  inputState->guessing++;
                  try {
                    {
                      match(LITERAL_typedef);
                      class_specifier();
                    }
                  } catch (ANTLR_USE_NAMESPACE(antlr)
                               RecognitionException& pe) {
                    synPredMatched82 = false;
                  }
                  rewind(_m82);
                  inputState->guessing--;
                }
                if (synPredMatched82) {
                  if (inputState->guessing == 0) {
#line 602 "CPP_parser.g"
                    if (statementTrace >= 1) {
                      printf("%d member_declaration Typedef class type\n",
                             LT(1)->getLine());
                    }

#line 3136 "CPPParser.cpp"
                  }
                  match(LITERAL_typedef);
                  class_decl_or_def(fs);
                  if (inputState->guessing == 0) {
#line 605 "CPP_parser.g"
                    _td = true;
#line 3143 "CPPParser.cpp"
                  }
                  {
                    switch (LA(1)) {
                      case ID:
                      case LITERAL__stdcall:
                      case LITERAL___stdcall:
                      case LPAREN:
                      case OPERATOR:
                      case LITERAL_this:
                      case LITERAL_true:
                      case LITERAL_false:
                      case TILDE:
                      case STAR:
                      case AMPERSAND:
                      case SCOPE:
                      case LITERAL__cdecl:
                      case LITERAL___cdecl:
                      case LITERAL__near:
                      case LITERAL___near:
                      case LITERAL__far:
                      case LITERAL___far:
                      case LITERAL___interrupt:
                      case LITERAL_pascal:
                      case LITERAL__pascal:
                      case LITERAL___pascal: {
                        init_declarator_list();
                        break;
                      }
                      case SEMICOLON: {
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  match(SEMICOLON);
                  if (inputState->guessing == 0) {
#line 605 "CPP_parser.g"
                    end_of_stmt();
#line 3187 "CPPParser.cpp"
                  }
                } else {
                  bool synPredMatched85 = false;
                  if (((LA(1) == LITERAL_typedef) && (LA(2) == LITERAL_enum))) {
                    int _m85 = mark();
                    synPredMatched85 = true;
                    inputState->guessing++;
                    try {
                      {
                        match(LITERAL_typedef);
                        match(LITERAL_enum);
                      }
                    } catch (ANTLR_USE_NAMESPACE(antlr)
                                 RecognitionException& pe) {
                      synPredMatched85 = false;
                    }
                    rewind(_m85);
                    inputState->guessing--;
                  }
                  if (synPredMatched85) {
                    if (inputState->guessing == 0) {
#line 608 "CPP_parser.g"
                      if (statementTrace >= 1) {
                        printf("%d member_declaration Typedef enum type\n",
                               LT(1)->getLine());
                      }

#line 3214 "CPPParser.cpp"
                    }
                    match(LITERAL_typedef);
                    enum_specifier();
                    if (inputState->guessing == 0) {
#line 611 "CPP_parser.g"
                      _td = true;
#line 3221 "CPPParser.cpp"
                    }
                    {
                      switch (LA(1)) {
                        case ID:
                        case LITERAL__stdcall:
                        case LITERAL___stdcall:
                        case LPAREN:
                        case OPERATOR:
                        case LITERAL_this:
                        case LITERAL_true:
                        case LITERAL_false:
                        case TILDE:
                        case STAR:
                        case AMPERSAND:
                        case SCOPE:
                        case LITERAL__cdecl:
                        case LITERAL___cdecl:
                        case LITERAL__near:
                        case LITERAL___near:
                        case LITERAL__far:
                        case LITERAL___far:
                        case LITERAL___interrupt:
                        case LITERAL_pascal:
                        case LITERAL__pascal:
                        case LITERAL___pascal: {
                          init_declarator_list();
                          break;
                        }
                        case SEMICOLON: {
                          break;
                        }
                        default: {
                          throw ANTLR_USE_NAMESPACE(antlr)
                              NoViableAltException(LT(1), getFilename());
                        }
                      }
                    }
                    match(SEMICOLON);
                    if (inputState->guessing == 0) {
#line 611 "CPP_parser.g"
                      end_of_stmt();
#line 3265 "CPPParser.cpp"
                    }
                  } else {
                    bool synPredMatched88 = false;
                    if (((_tokenSet_2.member(LA(1))) &&
                         (_tokenSet_3.member(LA(2))))) {
                      int _m88 = mark();
                      synPredMatched88 = true;
                      inputState->guessing++;
                      try {
                        {
                          declaration_specifiers();
                          function_declarator(0);
                          match(SEMICOLON);
                        }
                      } catch (ANTLR_USE_NAMESPACE(antlr)
                                   RecognitionException& pe) {
                        synPredMatched88 = false;
                      }
                      rewind(_m88);
                      inputState->guessing--;
                    }
                    if (synPredMatched88) {
                      if (inputState->guessing == 0) {
#line 614 "CPP_parser.g"
                        if (statementTrace >= 1) {
                          printf(
                              "%d member_declaration Typedef function type\n",
                              LT(1)->getLine());
                        }

#line 3293 "CPPParser.cpp"
                      }
                      declaration();
                    } else if ((_tokenSet_2.member(LA(1))) &&
                               (_tokenSet_3.member(LA(2)))) {
                      if (inputState->guessing == 0) {
#line 619 "CPP_parser.g"
                        if (statementTrace >= 1) {
                          printf(
                              "%d member_declaration Typedef variable type\n",
                              LT(1)->getLine());
                        }

#line 3303 "CPPParser.cpp"
                      }
                      declaration();
                    } else {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }
                }
              }
            } else {
              bool synPredMatched92 = false;
              if (((LA(1) == LITERAL_template) && (LA(2) == LESSTHAN))) {
                int _m92 = mark();
                synPredMatched92 = true;
                inputState->guessing++;
                try {
                  {
                    template_head();
                    {  // ( ... )*
                      for (;;) {
                        if ((_tokenSet_4.member(LA(1)))) {
                          fs = function_specifier();
                        } else {
                          goto _loop91;
                        }
                      }
                    _loop91:;
                    }  // ( ... )*
                    class_specifier();
                  }
                } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                  synPredMatched92 = false;
                }
                rewind(_m92);
                inputState->guessing--;
              }
              if (synPredMatched92) {
                if (inputState->guessing == 0) {
#line 627 "CPP_parser.g"
                  if (statementTrace >= 1) {
                    printf(
                        "%d member_declaration Templated class decl or def\n",
                        LT(1)->getLine());
                  }

#line 3349 "CPPParser.cpp"
                }
                template_head();
                {  // ( ... )*
                  for (;;) {
                    if ((_tokenSet_4.member(LA(1)))) {
                      fs = function_specifier();
                    } else {
                      goto _loop94;
                    }
                  }
                _loop94:;
                }  // ( ... )*
                class_decl_or_def(fs);
                {
                  switch (LA(1)) {
                    case ID:
                    case LITERAL__stdcall:
                    case LITERAL___stdcall:
                    case LPAREN:
                    case OPERATOR:
                    case LITERAL_this:
                    case LITERAL_true:
                    case LITERAL_false:
                    case TILDE:
                    case STAR:
                    case AMPERSAND:
                    case SCOPE:
                    case LITERAL__cdecl:
                    case LITERAL___cdecl:
                    case LITERAL__near:
                    case LITERAL___near:
                    case LITERAL__far:
                    case LITERAL___far:
                    case LITERAL___interrupt:
                    case LITERAL_pascal:
                    case LITERAL__pascal:
                    case LITERAL___pascal: {
                      init_declarator_list();
                      break;
                    }
                    case SEMICOLON: {
                      break;
                    }
                    default: {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }
                }
                match(SEMICOLON);
                if (inputState->guessing == 0) {
#line 630 "CPP_parser.g"
                  end_of_stmt();
#line 3407 "CPPParser.cpp"
                }
              } else {
                bool synPredMatched98 = false;
                if (((LA(1) == LITERAL_enum) && (_tokenSet_5.member(LA(2))))) {
                  int _m98 = mark();
                  synPredMatched98 = true;
                  inputState->guessing++;
                  try {
                    {
                      match(LITERAL_enum);
                      {
                        switch (LA(1)) {
                          case ID: {
                            match(ID);
                            break;
                          }
                          case LCURLY: {
                            break;
                          }
                          default: {
                            throw ANTLR_USE_NAMESPACE(antlr)
                                NoViableAltException(LT(1), getFilename());
                          }
                        }
                      }
                      match(LCURLY);
                    }
                  } catch (ANTLR_USE_NAMESPACE(antlr)
                               RecognitionException& pe) {
                    synPredMatched98 = false;
                  }
                  rewind(_m98);
                  inputState->guessing--;
                }
                if (synPredMatched98) {
                  if (inputState->guessing == 0) {
#line 634 "CPP_parser.g"
                    if (statementTrace >= 1) {
                      printf("%d member_declaration Enum definition\n",
                             LT(1)->getLine());
                    }

#line 3451 "CPPParser.cpp"
                  }
                  enum_specifier();
                  {
                    switch (LA(1)) {
                      case ID:
                      case COLON:
                      case LITERAL__stdcall:
                      case LITERAL___stdcall:
                      case LPAREN:
                      case OPERATOR:
                      case LITERAL_this:
                      case LITERAL_true:
                      case LITERAL_false:
                      case TILDE:
                      case STAR:
                      case AMPERSAND:
                      case SCOPE:
                      case LITERAL__cdecl:
                      case LITERAL___cdecl:
                      case LITERAL__near:
                      case LITERAL___near:
                      case LITERAL__far:
                      case LITERAL___far:
                      case LITERAL___interrupt:
                      case LITERAL_pascal:
                      case LITERAL__pascal:
                      case LITERAL___pascal: {
                        member_declarator_list();
                        break;
                      }
                      case SEMICOLON: {
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  match(SEMICOLON);
                  if (inputState->guessing == 0) {
#line 637 "CPP_parser.g"
                    end_of_stmt();
#line 3497 "CPPParser.cpp"
                  }
                } else {
                  bool synPredMatched101 = false;
                  if (((_tokenSet_8.member(LA(1))) &&
                       (_tokenSet_9.member(LA(2))))) {
                    int _m101 = mark();
                    synPredMatched101 = true;
                    inputState->guessing++;
                    try {
                      {
                        ctor_decl_spec();
                        if (!(qualifiedItemIsOneOf(qiCtor))) {
                          throw ANTLR_USE_NAMESPACE(antlr)
                              SemanticException("qualifiedItemIsOneOf(qiCtor)");
                        }
                        ctor_declarator(0);
                        match(SEMICOLON);
                      }
                    } catch (ANTLR_USE_NAMESPACE(antlr)
                                 RecognitionException& pe) {
                      synPredMatched101 = false;
                    }
                    rewind(_m101);
                    inputState->guessing--;
                  }
                  if (synPredMatched101) {
                    if (inputState->guessing == 0) {
#line 644 "CPP_parser.g"
                      if (statementTrace >= 1) {
                        printf("%d member_declaration Constructor declarator\n",
                               LT(1)->getLine());
                      }

#line 3527 "CPPParser.cpp"
                    }
                    ctor_decl_spec();
                    ctor_declarator(0);
                    match(SEMICOLON);
                    if (inputState->guessing == 0) {
#line 647 "CPP_parser.g"
                      end_of_stmt();
#line 3535 "CPPParser.cpp"
                    }
                  } else {
                    bool synPredMatched104 = false;
                    if (((_tokenSet_8.member(LA(1))) &&
                         (_tokenSet_9.member(LA(2))))) {
                      int _m104 = mark();
                      synPredMatched104 = true;
                      inputState->guessing++;
                      try {
                        {
                          ctor_decl_spec();
                          if (!(qualifiedItemIsOneOf(qiCtor))) {
                            throw ANTLR_USE_NAMESPACE(antlr) SemanticException(
                                "qualifiedItemIsOneOf(qiCtor)");
                          }
                          ctor_declarator(1);
                          {
                            switch (LA(1)) {
                              case COLON: {
                                match(COLON);
                                break;
                              }
                              case LCURLY: {
                                match(LCURLY);
                                break;
                              }
                              default: {
                                throw ANTLR_USE_NAMESPACE(antlr)
                                    NoViableAltException(LT(1), getFilename());
                              }
                            }
                          }
                        }
                      } catch (ANTLR_USE_NAMESPACE(antlr)
                                   RecognitionException& pe) {
                        synPredMatched104 = false;
                      }
                      rewind(_m104);
                      inputState->guessing--;
                    }
                    if (synPredMatched104) {
                      if (inputState->guessing == 0) {
#line 661 "CPP_parser.g"
                        if (statementTrace >= 1) {
                          printf(
                              "%d member_declaration Constructor definition\n",
                              LT(1)->getLine());
                        }

#line 3582 "CPPParser.cpp"
                      }
                      ctor_definition();
                    } else {
                      bool synPredMatched106 = false;
                      if (((_tokenSet_42.member(LA(1))) &&
                           (_tokenSet_7.member(LA(2))))) {
                        int _m106 = mark();
                        synPredMatched106 = true;
                        inputState->guessing++;
                        try {
                          {
                            dtor_head(0);
                            match(SEMICOLON);
                          }
                        } catch (ANTLR_USE_NAMESPACE(antlr)
                                     RecognitionException& pe) {
                          synPredMatched106 = false;
                        }
                        rewind(_m106);
                        inputState->guessing--;
                      }
                      if (synPredMatched106) {
                        if (inputState->guessing == 0) {
#line 670 "CPP_parser.g"
                          if (statementTrace >= 1) {
                            printf(
                                "%d member_declaration Destructor "
                                "declaration\n",
                                LT(1)->getLine());
                          }

#line 3610 "CPPParser.cpp"
                        }
                        dtor_head(0);
                        match(SEMICOLON);
                        if (inputState->guessing == 0) {
#line 673 "CPP_parser.g"
                          end_of_stmt();
#line 3617 "CPPParser.cpp"
                        }
                      } else {
                        bool synPredMatched108 = false;
                        if (((_tokenSet_42.member(LA(1))) &&
                             (_tokenSet_7.member(LA(2))))) {
                          int _m108 = mark();
                          synPredMatched108 = true;
                          inputState->guessing++;
                          try {
                            {
                              dtor_head(1);
                              match(LCURLY);
                            }
                          } catch (ANTLR_USE_NAMESPACE(antlr)
                                       RecognitionException& pe) {
                            synPredMatched108 = false;
                          }
                          rewind(_m108);
                          inputState->guessing--;
                        }
                        if (synPredMatched108) {
                          if (inputState->guessing == 0) {
#line 679 "CPP_parser.g"
                            if (statementTrace >= 1) {
                              printf(
                                  "%d member_declaration Destructor "
                                  "definition\n",
                                  LT(1)->getLine());
                            }

#line 3644 "CPPParser.cpp"
                          }
                          dtor_head(1);
                          dtor_body();
                        } else {
                          bool synPredMatched110 = false;
                          if (((_tokenSet_12.member(LA(1))) &&
                               (_tokenSet_13.member(LA(2))))) {
                            int _m110 = mark();
                            synPredMatched110 = true;
                            inputState->guessing++;
                            try {
                              {
                                declaration_specifiers();
                                function_declarator(0);
                                match(SEMICOLON);
                              }
                            } catch (ANTLR_USE_NAMESPACE(antlr)
                                         RecognitionException& pe) {
                              synPredMatched110 = false;
                            }
                            rewind(_m110);
                            inputState->guessing--;
                          }
                          if (synPredMatched110) {
                            if (inputState->guessing == 0) {
#line 686 "CPP_parser.g"
                              if (statementTrace >= 1) {
                                printf(
                                    "%d member_declaration Function "
                                    "declaration\n",
                                    LT(1)->getLine());
                              }

#line 3674 "CPPParser.cpp"
                            }
                            declaration_specifiers();
                            function_declarator(0);
                            match(SEMICOLON);
                            if (inputState->guessing == 0) {
#line 689 "CPP_parser.g"
                              end_of_stmt();
#line 3682 "CPPParser.cpp"
                            }
                          } else {
                            bool synPredMatched112 = false;
                            if (((_tokenSet_14.member(LA(1))) &&
                                 (_tokenSet_15.member(LA(2))))) {
                              int _m112 = mark();
                              synPredMatched112 = true;
                              inputState->guessing++;
                              try {
                                {
                                  declaration_specifiers();
                                  function_declarator(1);
                                  match(LCURLY);
                                }
                              } catch (ANTLR_USE_NAMESPACE(antlr)
                                           RecognitionException& pe) {
                                synPredMatched112 = false;
                              }
                              rewind(_m112);
                              inputState->guessing--;
                            }
                            if (synPredMatched112) {
                              if (inputState->guessing == 0) {
#line 693 "CPP_parser.g"
                                beginFieldDeclaration();
                                if (statementTrace >= 1) {
                                  printf(
                                      "%d member_declaration Function "
                                      "definition\n",
                                      LT(1)->getLine());
                                }

#line 3711 "CPPParser.cpp"
                              }
                              function_definition();
                            } else {
                              bool synPredMatched115 = false;
                              if (((LA(1) == LITERAL_inline ||
                                    LA(1) == OPERATOR) &&
                                   (_tokenSet_43.member(LA(2))))) {
                                int _m115 = mark();
                                synPredMatched115 = true;
                                inputState->guessing++;
                                try {
                                  {
                                    {
                                      switch (LA(1)) {
                                        case LITERAL_inline: {
                                          match(LITERAL_inline);
                                          break;
                                        }
                                        case OPERATOR: {
                                          break;
                                        }
                                        default: {
                                          throw ANTLR_USE_NAMESPACE(antlr)
                                              NoViableAltException(
                                                  LT(1), getFilename());
                                        }
                                      }
                                    }
                                    conversion_function_decl_or_def();
                                  }
                                } catch (ANTLR_USE_NAMESPACE(antlr)
                                             RecognitionException& pe) {
                                  synPredMatched115 = false;
                                }
                                rewind(_m115);
                                inputState->guessing--;
                              }
                              if (synPredMatched115) {
                                if (inputState->guessing == 0) {
#line 701 "CPP_parser.g"
                                  if (statementTrace >= 1) {
                                    printf(
                                        "%d member_declaration Operator "
                                        "function\n",
                                        LT(1)->getLine());
                                  }

#line 3755 "CPPParser.cpp"
                                }
                                {
                                  switch (LA(1)) {
                                    case LITERAL_inline: {
                                      match(LITERAL_inline);
                                      break;
                                    }
                                    case OPERATOR: {
                                      break;
                                    }
                                    default: {
                                      throw ANTLR_USE_NAMESPACE(antlr)
                                          NoViableAltException(LT(1),
                                                               getFilename());
                                    }
                                  }
                                }
                                conversion_function_decl_or_def();
                              } else {
                                bool synPredMatched118 = false;
                                if (((_tokenSet_44.member(LA(1))) &&
                                     (_tokenSet_45.member(LA(2))))) {
                                  int _m118 = mark();
                                  synPredMatched118 = true;
                                  inputState->guessing++;
                                  try {
                                    {
                                      qualified_id();
                                      match(SEMICOLON);
                                    }
                                  } catch (ANTLR_USE_NAMESPACE(antlr)
                                               RecognitionException& pe) {
                                    synPredMatched118 = false;
                                  }
                                  rewind(_m118);
                                  inputState->guessing--;
                                }
                                if (synPredMatched118) {
                                  if (inputState->guessing == 0) {
#line 710 "CPP_parser.g"
                                    if (statementTrace >= 1) {
                                      printf(
                                          "%d member_declaration Qualified "
                                          "ID\n",
                                          LT(1)->getLine());
                                    }

#line 3800 "CPPParser.cpp"
                                  }
                                  q = qualified_id();
                                  match(SEMICOLON);
                                  if (inputState->guessing == 0) {
#line 713 "CPP_parser.g"
                                    end_of_stmt();
#line 3807 "CPPParser.cpp"
                                  }
                                } else {
                                  bool synPredMatched121 = false;
                                  if (((_tokenSet_2.member(LA(1))) &&
                                       (_tokenSet_3.member(LA(2))))) {
                                    int _m121 = mark();
                                    synPredMatched121 = true;
                                    inputState->guessing++;
                                    try {
                                      {
                                        declaration_specifiers();
                                        {
                                          switch (LA(1)) {
                                            case ID:
                                            case LITERAL__stdcall:
                                            case LITERAL___stdcall:
                                            case LPAREN:
                                            case OPERATOR:
                                            case LITERAL_this:
                                            case LITERAL_true:
                                            case LITERAL_false:
                                            case TILDE:
                                            case STAR:
                                            case AMPERSAND:
                                            case SCOPE:
                                            case LITERAL__cdecl:
                                            case LITERAL___cdecl:
                                            case LITERAL__near:
                                            case LITERAL___near:
                                            case LITERAL__far:
                                            case LITERAL___far:
                                            case LITERAL___interrupt:
                                            case LITERAL_pascal:
                                            case LITERAL__pascal:
                                            case LITERAL___pascal: {
                                              init_declarator_list();
                                              break;
                                            }
                                            case SEMICOLON: {
                                              break;
                                            }
                                            default: {
                                              throw ANTLR_USE_NAMESPACE(antlr)
                                                  NoViableAltException(
                                                      LT(1), getFilename());
                                            }
                                          }
                                        }
                                        match(SEMICOLON);
                                      }
                                    } catch (ANTLR_USE_NAMESPACE(antlr)
                                                 RecognitionException& pe) {
                                      synPredMatched121 = false;
                                    }
                                    rewind(_m121);
                                    inputState->guessing--;
                                  }
                                  if (synPredMatched121) {
                                    if (inputState->guessing == 0) {
#line 718 "CPP_parser.g"
                                      beginFieldDeclaration();
                                      if (statementTrace >= 1) {
                                        printf(
                                            "%d member_declaration "
                                            "Declaration\n",
                                            LT(1)->getLine());
                                      }

#line 3873 "CPPParser.cpp"
                                    }
                                    declaration();
                                  } else {
                                    bool synPredMatched126 = false;
                                    if (((_tokenSet_16.member(LA(1))) &&
                                         (_tokenSet_17.member(LA(2))))) {
                                      int _m126 = mark();
                                      synPredMatched126 = true;
                                      inputState->guessing++;
                                      try {
                                        {
                                          {
                                            switch (LA(1)) {
                                              case LITERAL_friend: {
                                                match(LITERAL_friend);
                                                break;
                                              }
                                              case LITERAL_inline:
                                              case LITERAL_struct:
                                              case LITERAL_union:
                                              case LITERAL_class:
                                              case LITERAL__inline:
                                              case LITERAL___inline:
                                              case LITERAL_virtual:
                                              case LITERAL_explicit: {
                                                break;
                                              }
                                              default: {
                                                throw ANTLR_USE_NAMESPACE(antlr)
                                                    NoViableAltException(
                                                        LT(1), getFilename());
                                              }
                                            }
                                          }
                                          {  // ( ... )*
                                            for (;;) {
                                              if ((_tokenSet_4.member(LA(1)))) {
                                                fs = function_specifier();
                                              } else {
                                                goto _loop125;
                                              }
                                            }
                                          _loop125:;
                                          }  // ( ... )*
                                          class_specifier();
                                        }
                                      } catch (ANTLR_USE_NAMESPACE(antlr)
                                                   RecognitionException& pe) {
                                        synPredMatched126 = false;
                                      }
                                      rewind(_m126);
                                      inputState->guessing--;
                                    }
                                    if (synPredMatched126) {
                                      if (inputState->guessing == 0) {
#line 726 "CPP_parser.g"
                                        if (statementTrace >= 1) {
                                          printf(
                                              "%d member_declaration Class "
                                              "decl or def\n",
                                              LT(1)->getLine());
                                        }

#line 3936 "CPPParser.cpp"
                                      }
                                      {
                                        switch (LA(1)) {
                                          case LITERAL_friend: {
                                            match(LITERAL_friend);
                                            break;
                                          }
                                          case LITERAL_inline:
                                          case LITERAL_struct:
                                          case LITERAL_union:
                                          case LITERAL_class:
                                          case LITERAL__inline:
                                          case LITERAL___inline:
                                          case LITERAL_virtual:
                                          case LITERAL_explicit: {
                                            break;
                                          }
                                          default: {
                                            throw ANTLR_USE_NAMESPACE(antlr)
                                                NoViableAltException(
                                                    LT(1), getFilename());
                                          }
                                        }
                                      }
                                      {  // ( ... )*
                                        for (;;) {
                                          if ((_tokenSet_4.member(LA(1)))) {
                                            fs = function_specifier();
                                          } else {
                                            goto _loop129;
                                          }
                                        }
                                      _loop129:;
                                      }  // ( ... )*
                                      class_decl_or_def(fs);
                                      {
                                        switch (LA(1)) {
                                          case ID:
                                          case LITERAL__stdcall:
                                          case LITERAL___stdcall:
                                          case LPAREN:
                                          case OPERATOR:
                                          case LITERAL_this:
                                          case LITERAL_true:
                                          case LITERAL_false:
                                          case TILDE:
                                          case STAR:
                                          case AMPERSAND:
                                          case SCOPE:
                                          case LITERAL__cdecl:
                                          case LITERAL___cdecl:
                                          case LITERAL__near:
                                          case LITERAL___near:
                                          case LITERAL__far:
                                          case LITERAL___far:
                                          case LITERAL___interrupt:
                                          case LITERAL_pascal:
                                          case LITERAL__pascal:
                                          case LITERAL___pascal: {
                                            init_declarator_list();
                                            break;
                                          }
                                          case SEMICOLON: {
                                            break;
                                          }
                                          default: {
                                            throw ANTLR_USE_NAMESPACE(antlr)
                                                NoViableAltException(
                                                    LT(1), getFilename());
                                          }
                                        }
                                      }
                                      match(SEMICOLON);
                                      if (inputState->guessing == 0) {
#line 729 "CPP_parser.g"
                                        end_of_stmt();
#line 4017 "CPPParser.cpp"
                                      }
                                    } else {
                                      bool synPredMatched134 = false;
                                      if (((_tokenSet_46.member(LA(1))) &&
                                           (_tokenSet_47.member(LA(2))))) {
                                        int _m134 = mark();
                                        synPredMatched134 = true;
                                        inputState->guessing++;
                                        try {
                                          {
                                            {  // ( ... )*
                                              for (;;) {
                                                if ((_tokenSet_4.member(
                                                        LA(1)))) {
                                                  fs = function_specifier();
                                                } else {
                                                  goto _loop133;
                                                }
                                              }
                                            _loop133:;
                                            }  // ( ... )*
                                            function_declarator(0);
                                            match(SEMICOLON);
                                          }
                                        } catch (ANTLR_USE_NAMESPACE(antlr)
                                                     RecognitionException& pe) {
                                          synPredMatched134 = false;
                                        }
                                        rewind(_m134);
                                        inputState->guessing--;
                                      }
                                      if (synPredMatched134) {
                                        if (inputState->guessing == 0) {
#line 733 "CPP_parser.g"
                                          beginFieldDeclaration();
                                          fprintf(stderr,
                                                  "%d warning Function "
                                                  "declaration found without "
                                                  "return type\n",
                                                  LT(1)->getLine());
                                          if (statementTrace >= 1) {
                                            printf(
                                                "%d member_declaration "
                                                "Function declaration\n",
                                                LT(1)->getLine());
                                          }

#line 4058 "CPPParser.cpp"
                                        }
                                        {  // ( ... )*
                                          for (;;) {
                                            if ((_tokenSet_4.member(LA(1)))) {
                                              fs = function_specifier();
                                            } else {
                                              goto _loop136;
                                            }
                                          }
                                        _loop136:;
                                        }  // ( ... )*
                                        function_declarator(0);
                                        match(SEMICOLON);
                                        if (inputState->guessing == 0) {
#line 738 "CPP_parser.g"
                                          end_of_stmt();
#line 4077 "CPPParser.cpp"
                                        }
                                      } else if ((_tokenSet_38.member(LA(1))) &&
                                                 (_tokenSet_39.member(LA(2)))) {
                                        if (inputState->guessing == 0) {
#line 742 "CPP_parser.g"

                                          fprintf(stderr,
                                                  "%d warning Function "
                                                  "definition found without "
                                                  "return type\n",
                                                  LT(1)->getLine());
                                          if (statementTrace >= 1) {
                                            printf(
                                                "%d member_declaration "
                                                "Function definition without "
                                                "return type\n",
                                                LT(1)->getLine());
                                          }

#line 4088 "CPPParser.cpp"
                                        }
                                        function_declarator(1);
                                        compound_statement();
                                        if (inputState->guessing == 0) {
#line 747 "CPP_parser.g"
                                          endFunctionDefinition();
#line 4095 "CPPParser.cpp"
                                        }
                                      } else if ((LA(1) == LITERAL_template) &&
                                                 (LA(2) == LESSTHAN)) {
                                        if (inputState->guessing == 0) {
#line 750 "CPP_parser.g"
                                          beginTemplateDeclaration();
#line 4102 "CPPParser.cpp"
                                        }
                                        template_head();
                                        {
                                          bool synPredMatched140 = false;
                                          if (((_tokenSet_12.member(LA(1))) &&
                                               (_tokenSet_18.member(LA(2))))) {
                                            int _m140 = mark();
                                            synPredMatched140 = true;
                                            inputState->guessing++;
                                            try {
                                              {
                                                declaration_specifiers();
                                                {
                                                  switch (LA(1)) {
                                                    case ID:
                                                    case LITERAL__stdcall:
                                                    case LITERAL___stdcall:
                                                    case LPAREN:
                                                    case OPERATOR:
                                                    case LITERAL_this:
                                                    case LITERAL_true:
                                                    case LITERAL_false:
                                                    case TILDE:
                                                    case STAR:
                                                    case AMPERSAND:
                                                    case SCOPE:
                                                    case LITERAL__cdecl:
                                                    case LITERAL___cdecl:
                                                    case LITERAL__near:
                                                    case LITERAL___near:
                                                    case LITERAL__far:
                                                    case LITERAL___far:
                                                    case LITERAL___interrupt:
                                                    case LITERAL_pascal:
                                                    case LITERAL__pascal:
                                                    case LITERAL___pascal: {
                                                      init_declarator_list();
                                                      break;
                                                    }
                                                    case SEMICOLON: {
                                                      break;
                                                    }
                                                    default: {
                                                      throw ANTLR_USE_NAMESPACE(
                                                          antlr)
                                                          NoViableAltException(
                                                              LT(1),
                                                              getFilename());
                                                    }
                                                  }
                                                }
                                                match(SEMICOLON);
                                              }
                                            } catch (
                                                ANTLR_USE_NAMESPACE(antlr)
                                                    RecognitionException& pe) {
                                              synPredMatched140 = false;
                                            }
                                            rewind(_m140);
                                            inputState->guessing--;
                                          }
                                          if (synPredMatched140) {
                                            if (inputState->guessing == 0) {
#line 755 "CPP_parser.g"
                                              if (statementTrace >= 1) {
                                                printf(
                                                    "%d member_declaration "
                                                    "Templated forward "
                                                    "declaration\n",
                                                    LT(1)->getLine());
                                              }

#line 4167 "CPPParser.cpp"
                                            }
                                            declaration_specifiers();
                                            {
                                              switch (LA(1)) {
                                                case ID:
                                                case LITERAL__stdcall:
                                                case LITERAL___stdcall:
                                                case LPAREN:
                                                case OPERATOR:
                                                case LITERAL_this:
                                                case LITERAL_true:
                                                case LITERAL_false:
                                                case TILDE:
                                                case STAR:
                                                case AMPERSAND:
                                                case SCOPE:
                                                case LITERAL__cdecl:
                                                case LITERAL___cdecl:
                                                case LITERAL__near:
                                                case LITERAL___near:
                                                case LITERAL__far:
                                                case LITERAL___far:
                                                case LITERAL___interrupt:
                                                case LITERAL_pascal:
                                                case LITERAL__pascal:
                                                case LITERAL___pascal: {
                                                  init_declarator_list();
                                                  break;
                                                }
                                                case SEMICOLON: {
                                                  break;
                                                }
                                                default: {
                                                  throw ANTLR_USE_NAMESPACE(
                                                      antlr)
                                                      NoViableAltException(
                                                          LT(1), getFilename());
                                                }
                                              }
                                            }
                                            match(SEMICOLON);
                                            if (inputState->guessing == 0) {
#line 758 "CPP_parser.g"
                                              end_of_stmt();
#line 4212 "CPPParser.cpp"
                                            }
                                          } else {
                                            bool synPredMatched143 = false;
                                            if (((_tokenSet_2.member(LA(1))) &&
                                                 (_tokenSet_3.member(LA(2))))) {
                                              int _m143 = mark();
                                              synPredMatched143 = true;
                                              inputState->guessing++;
                                              try {
                                                {
                                                  declaration_specifiers();
                                                  function_declarator(0);
                                                  match(SEMICOLON);
                                                }
                                              } catch (ANTLR_USE_NAMESPACE(
                                                  antlr) RecognitionException&
                                                           pe) {
                                                synPredMatched143 = false;
                                              }
                                              rewind(_m143);
                                              inputState->guessing--;
                                            }
                                            if (synPredMatched143) {
                                              if (inputState->guessing == 0) {
#line 762 "CPP_parser.g"
                                                if (statementTrace >= 1) {
                                                  printf(
                                                      "%d member_declaration "
                                                      "Templated function "
                                                      "declaration\n",
                                                      LT(1)->getLine());
                                                }

#line 4240 "CPPParser.cpp"
                                              }
                                              declaration();
                                            } else {
                                              bool synPredMatched145 = false;
                                              if (((_tokenSet_14.member(
                                                       LA(1))) &&
                                                   (_tokenSet_15.member(
                                                       LA(2))))) {
                                                int _m145 = mark();
                                                synPredMatched145 = true;
                                                inputState->guessing++;
                                                try {
                                                  {
                                                    declaration_specifiers();
                                                    function_declarator(1);
                                                    match(LCURLY);
                                                  }
                                                } catch (ANTLR_USE_NAMESPACE(
                                                    antlr) RecognitionException&
                                                             pe) {
                                                  synPredMatched145 = false;
                                                }
                                                rewind(_m145);
                                                inputState->guessing--;
                                              }
                                              if (synPredMatched145) {
                                                if (inputState->guessing == 0) {
#line 769 "CPP_parser.g"
                                                  if (statementTrace >= 1) {
                                                    printf(
                                                        "%d member_declaration "
                                                        "Templated function "
                                                        "definition\n",
                                                        LT(1)->getLine());
                                                  }

#line 4269 "CPPParser.cpp"
                                                }
                                                function_definition();
                                              } else {
                                                bool synPredMatched147 = false;
                                                if (((_tokenSet_8.member(
                                                         LA(1))) &&
                                                     (_tokenSet_9.member(
                                                         LA(2))))) {
                                                  int _m147 = mark();
                                                  synPredMatched147 = true;
                                                  inputState->guessing++;
                                                  try {
                                                    {
                                                      ctor_decl_spec();
                                                      if (!(qualifiedItemIsOneOf(
                                                              qiCtor))) {
                                                        throw ANTLR_USE_NAMESPACE(
                                                            antlr)
                                                            SemanticException(
                                                                "qualifiedItemI"
                                                                "sOneOf("
                                                                "qiCtor)");
                                                      }
                                                    }
                                                  } catch (
                                                      ANTLR_USE_NAMESPACE(antlr)
                                                          RecognitionException&
                                                              pe) {
                                                    synPredMatched147 = false;
                                                  }
                                                  rewind(_m147);
                                                  inputState->guessing--;
                                                }
                                                if (synPredMatched147) {
                                                  if (inputState->guessing ==
                                                      0) {
#line 779 "CPP_parser.g"
                                                    if (statementTrace >= 1) {
                                                      printf(
                                                          "%d "
                                                          "member_declaration "
                                                          "Templated "
                                                          "constructor "
                                                          "definition\n",
                                                          LT(1)->getLine());
                                                    }

#line 4298 "CPPParser.cpp"
                                                  }
                                                  ctor_definition();
                                                } else if ((LA(1) ==
                                                            OPERATOR) &&
                                                           (_tokenSet_12.member(
                                                               LA(2)))) {
                                                  if (inputState->guessing ==
                                                      0) {
#line 785 "CPP_parser.g"
                                                    if (statementTrace >= 1) {
                                                      printf(
                                                          "%d "
                                                          "member_declaration "
                                                          "Templated operator "
                                                          "function\n",
                                                          LT(1)->getLine());
                                                    }

#line 4308 "CPPParser.cpp"
                                                  }
                                                  conversion_function_decl_or_def();
                                                } else if (
                                                    ((LA(1) >= LITERAL_struct &&
                                                      LA(1) <=
                                                          LITERAL_class)) &&
                                                    (LA(2) == ID ||
                                                     LA(2) == LCURLY)) {
                                                  if (inputState->guessing ==
                                                      0) {
#line 791 "CPP_parser.g"
                                                    if (statementTrace >= 1) {
                                                      printf(
                                                          "%d "
                                                          "member_declaration "
                                                          "Templated class "
                                                          "definition\n",
                                                          LT(1)->getLine());
                                                    }

#line 4318 "CPPParser.cpp"
                                                  }
                                                  class_head();
                                                  declaration_specifiers();
                                                  {
                                                    switch (LA(1)) {
                                                      case ID:
                                                      case LITERAL__stdcall:
                                                      case LITERAL___stdcall:
                                                      case LPAREN:
                                                      case OPERATOR:
                                                      case LITERAL_this:
                                                      case LITERAL_true:
                                                      case LITERAL_false:
                                                      case TILDE:
                                                      case STAR:
                                                      case AMPERSAND:
                                                      case SCOPE:
                                                      case LITERAL__cdecl:
                                                      case LITERAL___cdecl:
                                                      case LITERAL__near:
                                                      case LITERAL___near:
                                                      case LITERAL__far:
                                                      case LITERAL___far:
                                                      case LITERAL___interrupt:
                                                      case LITERAL_pascal:
                                                      case LITERAL__pascal:
                                                      case LITERAL___pascal: {
                                                        init_declarator_list();
                                                        break;
                                                      }
                                                      case SEMICOLON: {
                                                        break;
                                                      }
                                                      default: {
                                                        throw ANTLR_USE_NAMESPACE(
                                                            antlr)
                                                            NoViableAltException(
                                                                LT(1),
                                                                getFilename());
                                                      }
                                                    }
                                                  }
                                                  match(SEMICOLON);
                                                  if (inputState->guessing ==
                                                      0) {
#line 794 "CPP_parser.g"
                                                    end_of_stmt();
#line 4364 "CPPParser.cpp"
                                                  }
                                                } else {
                                                  throw ANTLR_USE_NAMESPACE(
                                                      antlr)
                                                      NoViableAltException(
                                                          LT(1), getFilename());
                                                }
                                              }
                                            }
                                          }
                                        }
                                        if (inputState->guessing == 0) {
#line 796 "CPP_parser.g"
                                          endTemplateDeclaration();
#line 4375 "CPPParser.cpp"
                                        }
                                      } else {
                                        throw ANTLR_USE_NAMESPACE(antlr)
                                            NoViableAltException(LT(1),
                                                                 getFilename());
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::member_declarator_list() {
  try {  // for error handling
    member_declarator();
    {
      switch (LA(1)) {
        case ASSIGNEQUAL: {
          match(ASSIGNEQUAL);
          match(OCTALINT);
          break;
        }
        case SEMICOLON:
        case COMMA: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          member_declarator();
          {
            switch (LA(1)) {
              case ASSIGNEQUAL: {
                match(ASSIGNEQUAL);
                match(OCTALINT);
                break;
              }
              case SEMICOLON:
              case COMMA: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
        } else {
          goto _loop253;
        }
      }
    _loop253:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_22);
    } else {
      throw;
    }
  }
}

void CPPParser::ctor_declarator(int definition) {
#line 1402 "CPP_parser.g"
  char* q;
#line 4465 "CPPParser.cpp"

  try {  // for error handling
    q = qualified_ctor_id();
    if (inputState->guessing == 0) {
#line 1406 "CPP_parser.g"
      declaratorParameterList(definition);
#line 4472 "CPPParser.cpp"
    }
    match(LPAREN);
    {
      switch (LA(1)) {
        case LITERAL_typedef:
        case LITERAL_enum:
        case ID:
        case LITERAL_inline:
        case LITERAL_friend:
        case LITERAL_extern:
        case LITERAL_struct:
        case LITERAL_union:
        case LITERAL_class:
        case LITERAL__stdcall:
        case LITERAL___stdcall:
        case LITERAL_GFEXCLUDE:
        case LITERAL_GFINCLUDE:
        case LITERAL_GFID:
        case LITERAL_GFUNREAD:
        case LITERAL_GFARRAYSIZE:
        case LPAREN:
        case LITERAL_GFARRAYSIZES:
        case LITERAL_GFARRAYELEMSIZE:
        case LITERAL_auto:
        case LITERAL_register:
        case LITERAL_static:
        case LITERAL_mutable:
        case LITERAL__inline:
        case LITERAL___inline:
        case LITERAL_virtual:
        case LITERAL_explicit:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case LITERAL_const:
        case LITERAL___const:
        case LITERAL_volatile:
        case LITERAL___volatile__:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case ELLIPSIS:
        case SCOPE:
        case LITERAL__cdecl:
        case LITERAL___cdecl:
        case LITERAL__near:
        case LITERAL___near:
        case LITERAL__far:
        case LITERAL___far:
        case LITERAL___interrupt:
        case LITERAL_pascal:
        case LITERAL__pascal:
        case LITERAL___pascal: {
          parameter_list();
          break;
        }
        case RPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(RPAREN);
    if (inputState->guessing == 0) {
#line 1408 "CPP_parser.g"
      declaratorEndParameterList(definition);
#line 4577 "CPPParser.cpp"
    }
    {
      switch (LA(1)) {
        case LITERAL_throw: {
          exception_specification();
          break;
        }
        case SEMICOLON:
        case LCURLY:
        case COLON: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_48);
    } else {
      throw;
    }
  }
}

void CPPParser::compound_statement() {
  try {  // for error handling
    match(LCURLY);
    if (inputState->guessing == 0) {
#line 1746 "CPP_parser.g"
      end_of_stmt();
      enterNewLocalScope();

#line 4618 "CPPParser.cpp"
    }
    {
      if ((_tokenSet_49.member(LA(1)))) {
        statement_list();
      } else if ((LA(1) == RCURLY)) {
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
    match(RCURLY);
    if (inputState->guessing == 0) {
#line 1751 "CPP_parser.g"
      exitLocalScope();
#line 4635 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_50);
    } else {
      throw;
    }
  }
}

void CPPParser::class_head() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_struct: {
          match(LITERAL_struct);
          break;
        }
        case LITERAL_union: {
          match(LITERAL_union);
          break;
        }
        case LITERAL_class: {
          match(LITERAL_class);
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    {
      switch (LA(1)) {
        case ID: {
          match(ID);
          {
            switch (LA(1)) {
              case LESSTHAN: {
                match(LESSTHAN);
                template_argument_list();
                match(GREATERTHAN);
                break;
              }
              case LCURLY:
              case COLON: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          {
            switch (LA(1)) {
              case COLON: {
                base_clause();
                break;
              }
              case LCURLY: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case LCURLY: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(LCURLY);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_12);
    } else {
      throw;
    }
  }
}

void CPPParser::access_specifier() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_public: {
          match(LITERAL_public);
          break;
        }
        case LITERAL_protected: {
          match(LITERAL_protected);
          break;
        }
        case LITERAL_private: {
          match(LITERAL_private);
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_51);
    } else {
      throw;
    }
  }
}

void CPPParser::linkage_specification() {
  try {  // for error handling
    match(LITERAL_extern);
    match(StringLiteral);
    {
      switch (LA(1)) {
        case LCURLY: {
          match(LCURLY);
          {  // ( ... )*
            for (;;) {
              if ((_tokenSet_0.member(LA(1)))) {
                external_declaration();
              } else {
                goto _loop164;
              }
            }
          _loop164:;
          }  // ( ... )*
          match(RCURLY);
          break;
        }
        case LITERAL_typedef:
        case LITERAL_enum:
        case ID:
        case LITERAL_inline:
        case LITERAL_friend:
        case LITERAL_extern:
        case LITERAL_struct:
        case LITERAL_union:
        case LITERAL_class:
        case LITERAL__stdcall:
        case LITERAL___stdcall:
        case LITERAL_GFEXCLUDE:
        case LITERAL_GFINCLUDE:
        case LITERAL_GFID:
        case LITERAL_GFUNREAD:
        case LITERAL_GFARRAYSIZE:
        case LITERAL_GFARRAYSIZES:
        case LITERAL_GFARRAYELEMSIZE:
        case LITERAL_auto:
        case LITERAL_register:
        case LITERAL_static:
        case LITERAL_mutable:
        case LITERAL__inline:
        case LITERAL___inline:
        case LITERAL_virtual:
        case LITERAL_explicit:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case LITERAL_const:
        case LITERAL___const:
        case LITERAL_volatile:
        case LITERAL___volatile__:
        case LITERAL_using:
        case SCOPE: {
          declaration();
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

void CPPParser::using_statement() {
#line 1836 "CPP_parser.g"
  char* qid;
#line 4890 "CPPParser.cpp"

  try {  // for error handling
    match(LITERAL_using);
    {
      switch (LA(1)) {
        case LITERAL_namespace: {
          match(LITERAL_namespace);
          qid = qualified_id();
          break;
        }
        case ID:
        case LITERAL_typename:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case SCOPE: {
          {
            switch (LA(1)) {
              case LITERAL_typename: {
                match(LITERAL_typename);
                break;
              }
              case ID:
              case OPERATOR:
              case LITERAL_this:
              case LITERAL_true:
              case LITERAL_false:
              case SCOPE: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          qid = qualified_id();
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(SEMICOLON);
    if (inputState->guessing == 0) {
#line 1843 "CPP_parser.g"
      end_of_stmt();
#line 4945 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

void CPPParser::template_argument_list() {
  try {  // for error handling
    template_argument();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          template_argument();
        } else {
          goto _loop385;
        }
      }
    _loop385:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_52);
    } else {
      throw;
    }
  }
}

void CPPParser::base_clause() {
  try {  // for error handling
    match(COLON);
    base_specifier();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          base_specifier();
        } else {
          goto _loop220;
        }
      }
    _loop220:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_53);
    } else {
      throw;
    }
  }
}

CPPParser::StorageClass CPPParser::storage_class_specifier() {
#line 928 "CPP_parser.g"
  CPPParser::StorageClass sc = scInvalid;
#line 5018 "CPPParser.cpp"

  try {  // for error handling
    switch (LA(1)) {
      case LITERAL_auto: {
        match(LITERAL_auto);
        if (inputState->guessing == 0) {
#line 929 "CPP_parser.g"
          sc = scAUTO;
#line 5028 "CPPParser.cpp"
        }
        break;
      }
      case LITERAL_register: {
        match(LITERAL_register);
        if (inputState->guessing == 0) {
#line 930 "CPP_parser.g"
          sc = scREGISTER;
#line 5038 "CPPParser.cpp"
        }
        break;
      }
      case LITERAL_static: {
        match(LITERAL_static);
        if (inputState->guessing == 0) {
#line 931 "CPP_parser.g"
          sc = scSTATIC;
#line 5048 "CPPParser.cpp"
        }
        break;
      }
      case LITERAL_extern: {
        match(LITERAL_extern);
        if (inputState->guessing == 0) {
#line 932 "CPP_parser.g"
          sc = scEXTERN;
#line 5058 "CPPParser.cpp"
        }
        break;
      }
      case LITERAL_mutable: {
        match(LITERAL_mutable);
        if (inputState->guessing == 0) {
#line 933 "CPP_parser.g"
          sc = scMUTABLE;
#line 5068 "CPPParser.cpp"
        }
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_12);
    } else {
      throw;
    }
  }
  return sc;
}

CPPParser::TypeQualifier CPPParser::type_qualifier() {
#line 1025 "CPP_parser.g"
  CPPParser::TypeQualifier tq = tqInvalid;
#line 5092 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_const:
        case LITERAL___const: {
          {
            switch (LA(1)) {
              case LITERAL_const: {
                match(LITERAL_const);
                break;
              }
              case LITERAL___const: {
                match(LITERAL___const);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          if (inputState->guessing == 0) {
#line 1027 "CPP_parser.g"
            tq = tqCONST;
#line 5121 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_volatile:
        case LITERAL___volatile__: {
          {
            switch (LA(1)) {
              case LITERAL_volatile: {
                match(LITERAL_volatile);
                break;
              }
              case LITERAL___volatile__: {
                match(LITERAL___volatile__);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          if (inputState->guessing == 0) {
#line 1028 "CPP_parser.g"
            tq = tqVOLATILE;
#line 5149 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_54);
    } else {
      throw;
    }
  }
  return tq;
}

CPPParser::TypeSpecifier CPPParser::type_specifier() {
#line 944 "CPP_parser.g"
  CPPParser::TypeSpecifier ts = tsInvalid;
#line 5174 "CPPParser.cpp"
#line 944 "CPP_parser.g"

  TypeQualifier tq = tqInvalid;

#line 5179 "CPPParser.cpp"

  try {  // for error handling
    ts = simple_type_specifier();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_24);
    } else {
      throw;
    }
  }
  return ts;
}

CPPParser::TypeSpecifier CPPParser::simple_type_specifier() {
#line 953 "CPP_parser.g"
  CPPParser::TypeSpecifier ts = tsInvalid;
#line 5198 "CPPParser.cpp"
#line 953 "CPP_parser.g"
  char* s;
  ts = tsInvalid;

#line 5203 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_typename: {
          match(LITERAL_typename);
          s = qualified_type();
          if (inputState->guessing == 0) {
#line 962 "CPP_parser.g"
            declaratorID(s, qiType);
#line 5215 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec: {
          {  // ( ... )+
            int _cnt192 = 0;
            for (;;) {
              switch (LA(1)) {
                case LITERAL_char: {
                  match(LITERAL_char);
                  if (inputState->guessing == 0) {
#line 964 "CPP_parser.g"
                    ts |= tsCHAR;
#line 5261 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_wchar_t: {
                  match(LITERAL_wchar_t);
                  if (inputState->guessing == 0) {
#line 965 "CPP_parser.g"
                    ts |= tsWCHAR_T;
#line 5271 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_bool: {
                  match(LITERAL_bool);
                  if (inputState->guessing == 0) {
#line 966 "CPP_parser.g"
                    ts |= tsBOOL;
#line 5281 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_short: {
                  match(LITERAL_short);
                  if (inputState->guessing == 0) {
#line 967 "CPP_parser.g"
                    ts |= tsSHORT;
#line 5291 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_int: {
                  match(LITERAL_int);
                  if (inputState->guessing == 0) {
#line 968 "CPP_parser.g"
                    ts |= tsINT;
#line 5301 "CPPParser.cpp"
                  }
                  break;
                }
                case 50:
                case 51:
                case 52: {
                  {
                    switch (LA(1)) {
                      case 50: {
                        match(50);
                        break;
                      }
                      case 51: {
                        match(51);
                        break;
                      }
                      case 52: {
                        match(52);
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  if (inputState->guessing == 0) {
#line 969 "CPP_parser.g"
                    ts |= tsINT;
#line 5335 "CPPParser.cpp"
                  }
                  break;
                }
                case 53:
                case 54:
                case 55: {
                  {
                    switch (LA(1)) {
                      case 53: {
                        match(53);
                        break;
                      }
                      case 54: {
                        match(54);
                        break;
                      }
                      case 55: {
                        match(55);
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  if (inputState->guessing == 0) {
#line 970 "CPP_parser.g"
                    ts |= tsINT;
#line 5369 "CPPParser.cpp"
                  }
                  break;
                }
                case 56:
                case 57:
                case 58: {
                  {
                    switch (LA(1)) {
                      case 56: {
                        match(56);
                        break;
                      }
                      case 57: {
                        match(57);
                        break;
                      }
                      case 58: {
                        match(58);
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  if (inputState->guessing == 0) {
#line 971 "CPP_parser.g"
                    ts |= tsLONG;
#line 5403 "CPPParser.cpp"
                  }
                  break;
                }
                case 59:
                case 60:
                case 61: {
                  {
                    switch (LA(1)) {
                      case 59: {
                        match(59);
                        break;
                      }
                      case 60: {
                        match(60);
                        break;
                      }
                      case 61: {
                        match(61);
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  if (inputState->guessing == 0) {
#line 972 "CPP_parser.g"
                    ts |= tsLONG;
#line 5437 "CPPParser.cpp"
                  }
                  break;
                }
                case 62: {
                  { match(62); }
                  if (inputState->guessing == 0) {
#line 973 "CPP_parser.g"
                    ts |= (tsUNSIGNED | tsINT);
#line 5449 "CPPParser.cpp"
                  }
                  break;
                }
                case 63: {
                  { match(63); }
                  if (inputState->guessing == 0) {
#line 974 "CPP_parser.g"
                    ts |= (tsUNSIGNED | tsINT);
#line 5461 "CPPParser.cpp"
                  }
                  break;
                }
                case 64: {
                  { match(64); }
                  if (inputState->guessing == 0) {
#line 975 "CPP_parser.g"
                    ts |= (tsUNSIGNED | tsLONG);
#line 5473 "CPPParser.cpp"
                  }
                  break;
                }
                case 65: {
                  { match(65); }
                  if (inputState->guessing == 0) {
#line 976 "CPP_parser.g"
                    ts |= (tsUNSIGNED | tsLONG);
#line 5485 "CPPParser.cpp"
                  }
                  break;
                }
                case 66:
                case 67: {
                  {
                    switch (LA(1)) {
                      case 66: {
                        match(66);
                        break;
                      }
                      case 67: {
                        match(67);
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  if (inputState->guessing == 0) {
#line 977 "CPP_parser.g"
                    ts |= tsLONG;
#line 5513 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_long: {
                  match(LITERAL_long);
                  if (inputState->guessing == 0) {
#line 978 "CPP_parser.g"
                    ts |= tsLONG;
#line 5523 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_signed: {
                  match(LITERAL_signed);
                  if (inputState->guessing == 0) {
#line 979 "CPP_parser.g"
                    ts |= tsSIGNED;
#line 5533 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_unsigned: {
                  match(LITERAL_unsigned);
                  if (inputState->guessing == 0) {
#line 980 "CPP_parser.g"
                    ts |= tsUNSIGNED;
#line 5543 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_float: {
                  match(LITERAL_float);
                  if (inputState->guessing == 0) {
#line 981 "CPP_parser.g"
                    ts |= tsFLOAT;
#line 5553 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_double: {
                  match(LITERAL_double);
                  if (inputState->guessing == 0) {
#line 982 "CPP_parser.g"
                    ts |= tsDOUBLE;
#line 5563 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL_void: {
                  match(LITERAL_void);
                  if (inputState->guessing == 0) {
#line 983 "CPP_parser.g"
                    ts |= tsVOID;
#line 5573 "CPPParser.cpp"
                  }
                  break;
                }
                case LITERAL__declspec:
                case LITERAL___declspec: {
                  {
                    switch (LA(1)) {
                      case LITERAL__declspec: {
                        match(LITERAL__declspec);
                        break;
                      }
                      case LITERAL___declspec: {
                        match(LITERAL___declspec);
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  match(LPAREN);
                  match(ID);
                  match(RPAREN);
                  break;
                }
                default: {
                  if (_cnt192 >= 1) {
                    goto _loop192;
                  } else {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
              _cnt192++;
            }
          _loop192:;
          }  // ( ... )+
          break;
        }
        default:
          if (((LA(1) == ID || LA(1) == SCOPE)) &&
              (qualifiedItemIsOneOf(qiType | qiCtor))) {
            s = qualified_type();
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_24);
    } else {
      throw;
    }
  }
  return ts;
}

char* CPPParser::qualified_type() {
#line 994 "CPP_parser.g"
  char* q = NULL;
#line 5638 "CPPParser.cpp"
  ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken;
#line 994 "CPP_parser.g"
  char* s;
  static char qitem[CPPParser_MaxQualifiedItemSize + 1];
#line 5642 "CPPParser.cpp"

  try {  // for error handling
    s = scope_override();
    id = LT(1);
    match(ID);
    {
      if ((LA(1) == LESSTHAN) && (_tokenSet_55.member(LA(2)))) {
        match(LESSTHAN);
        template_argument_list();
        match(GREATERTHAN);
      } else if ((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2)))) {
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
    if (inputState->guessing == 0) {
#line 1008 "CPP_parser.g"

      strcpy(qitem, s);
      strcat(qitem, (id->getText()).data());
      q = qitem;

#line 5668 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_56);
    } else {
      throw;
    }
  }
  return q;
}

void CPPParser::class_prefix() {
  try {  // for error handling
    {    // ( ... )*
      for (;;) {
        if ((LA(1) == LITERAL__declspec || LA(1) == LITERAL___declspec)) {
          {
            switch (LA(1)) {
              case LITERAL__declspec: {
                match(LITERAL__declspec);
                break;
              }
              case LITERAL___declspec: {
                match(LITERAL___declspec);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          match(LPAREN);
          expression();
          match(RPAREN);
        } else {
          goto _loop204;
        }
      }
    _loop204:;
    }  // ( ... )*
    if (inputState->guessing == 0) {
#line 1036 "CPP_parser.g"

#line 5721 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_58);
    } else {
      throw;
    }
  }
}

void CPPParser::expression() {
  try {  // for error handling
    assignment_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          assignment_expression();
        } else {
          goto _loop444;
        }
      }
    _loop444:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_59);
    } else {
      throw;
    }
  }
}

void CPPParser::base_specifier() {
#line 1089 "CPP_parser.g"
  char* qt;
#line 5765 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_virtual: {
          match(LITERAL_virtual);
          {
            switch (LA(1)) {
              case LITERAL_public:
              case LITERAL_protected:
              case LITERAL_private: {
                access_specifier();
                break;
              }
              case ID:
              case SCOPE: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          qt = qualified_type();
          break;
        }
        case LITERAL_public:
        case LITERAL_protected:
        case LITERAL_private: {
          access_specifier();
          {
            switch (LA(1)) {
              case LITERAL_virtual: {
                match(LITERAL_virtual);
                break;
              }
              case ID:
              case SCOPE: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          qt = qualified_type();
          break;
        }
        case ID:
        case SCOPE: {
          qt = qualified_type();
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_60);
    } else {
      throw;
    }
  }
}

void CPPParser::enumerator_list() {
  try {  // for error handling
    enumerator();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          enumerator();
        } else {
          goto _loop232;
        }
      }
    _loop232:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_61);
    } else {
      throw;
    }
  }
}

void CPPParser::enumerator() {
  ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken;

  try {  // for error handling
    id = LT(1);
    match(ID);
    {
      switch (LA(1)) {
        case ASSIGNEQUAL: {
          match(ASSIGNEQUAL);
          constant_expression();
          break;
        }
        case RCURLY:
        case COMMA: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    if (inputState->guessing == 0) {
#line 1132 "CPP_parser.g"
      enumElement((id->getText()).data());
#line 5901 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_62);
    } else {
      throw;
    }
  }
}

void CPPParser::constant_expression() {
  try {  // for error handling
    conditional_expression();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_63);
    } else {
      throw;
    }
  }
}

void CPPParser::optor() {
  try {  // for error handling
    switch (LA(1)) {
      case LITERAL_new: {
        match(LITERAL_new);
        {
          if ((LA(1) == LSQUARE) && (LA(2) == RSQUARE)) {
            match(LSQUARE);
            match(RSQUARE);
          } else if ((_tokenSet_64.member(LA(1))) &&
                     (_tokenSet_57.member(LA(2)))) {
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        break;
      }
      case LITERAL_delete: {
        match(LITERAL_delete);
        {
          if ((LA(1) == LSQUARE) && (LA(2) == RSQUARE)) {
            match(LSQUARE);
            match(RSQUARE);
          } else if ((_tokenSet_64.member(LA(1))) &&
                     (_tokenSet_57.member(LA(2)))) {
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        break;
      }
      case LPAREN: {
        match(LPAREN);
        match(RPAREN);
        break;
      }
      case LSQUARE: {
        match(LSQUARE);
        match(RSQUARE);
        break;
      }
      case LESSTHAN:
      case GREATERTHAN:
      case ASSIGNEQUAL:
      case COMMA:
      case TILDE:
      case STAR:
      case AMPERSAND:
      case TIMESEQUAL:
      case DIVIDEEQUAL:
      case MINUSEQUAL:
      case PLUSEQUAL:
      case MODEQUAL:
      case SHIFTLEFTEQUAL:
      case SHIFTRIGHTEQUAL:
      case BITWISEANDEQUAL:
      case BITWISEXOREQUAL:
      case BITWISEOREQUAL:
      case OR:
      case AND:
      case BITWISEOR:
      case BITWISEXOR:
      case NOTEQUAL:
      case EQUAL:
      case LESSTHANOREQUALTO:
      case GREATERTHANOREQUALTO:
      case SHIFTLEFT:
      case SHIFTRIGHT:
      case PLUS:
      case MINUS:
      case DIVIDE:
      case MOD:
      case POINTERTOMBR:
      case PLUSPLUS:
      case MINUSMINUS:
      case POINTERTO:
      case NOT: {
        optor_simple_tokclass();
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_64);
    } else {
      throw;
    }
  }
}

void CPPParser::typeID() {
  try {  // for error handling
    if (!(isTypeName((LT(1)->getText()).data()))) {
      throw ANTLR_USE_NAMESPACE(antlr)
          SemanticException("isTypeName((LT(1)->getText()).data())");
    }
    match(ID);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_1);
    } else {
      throw;
    }
  }
}

void CPPParser::init_declarator() {
  try {  // for error handling
    declarator();
    {
      switch (LA(1)) {
        case ASSIGNEQUAL: {
          match(ASSIGNEQUAL);
          initializer();
          break;
        }
        case LPAREN: {
          match(LPAREN);
          expression_list();
          match(RPAREN);
          break;
        }
        case SEMICOLON:
        case COMMA: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_65);
    } else {
      throw;
    }
  }
}

void CPPParser::declarator() {
  try {  // for error handling
    bool synPredMatched261 = false;
    if (((_tokenSet_25.member(LA(1))) && (_tokenSet_66.member(LA(2))))) {
      int _m261 = mark();
      synPredMatched261 = true;
      inputState->guessing++;
      try {
        { ptr_operator(); }
      } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
        synPredMatched261 = false;
      }
      rewind(_m261);
      inputState->guessing--;
    }
    if (synPredMatched261) {
      ptr_operator();
      declarator();
    } else if ((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
      direct_declarator();
    } else {
      throw ANTLR_USE_NAMESPACE(antlr)
          NoViableAltException(LT(1), getFilename());
    }

  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_69);
    } else {
      throw;
    }
  }
}

void CPPParser::initializer() {
  try {  // for error handling
    switch (LA(1)) {
      case ID:
      case StringLiteral:
      case LPAREN:
      case LITERAL_typename:
      case LITERAL_char:
      case LITERAL_wchar_t:
      case LITERAL_bool:
      case LITERAL_short:
      case LITERAL_int:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 58:
      case 59:
      case 60:
      case 61:
      case 62:
      case 63:
      case 64:
      case 65:
      case 66:
      case 67:
      case LITERAL_long:
      case LITERAL_signed:
      case LITERAL_unsigned:
      case LITERAL_float:
      case LITERAL_double:
      case LITERAL_void:
      case LITERAL__declspec:
      case LITERAL___declspec:
      case OPERATOR:
      case LITERAL_this:
      case LITERAL_true:
      case LITERAL_false:
      case OCTALINT:
      case TILDE:
      case STAR:
      case AMPERSAND:
      case PLUS:
      case MINUS:
      case PLUSPLUS:
      case MINUSMINUS:
      case LITERAL_sizeof:
      case LITERAL___alignof__:
      case SCOPE:
      case LITERAL_dynamic_cast:
      case LITERAL_static_cast:
      case LITERAL_reinterpret_cast:
      case LITERAL_const_cast:
      case LITERAL_typeid:
      case DECIMALINT:
      case HEXADECIMALINT:
      case CharLiteral:
      case WCharLiteral:
      case WStringLiteral:
      case FLOATONE:
      case FLOATTWO:
      case NOT:
      case LITERAL_new:
      case LITERAL_delete: {
        remainder_expression();
        break;
      }
      case LCURLY: {
        match(LCURLY);
        initializer();
        {  // ( ... )*
          for (;;) {
            if ((LA(1) == COMMA)) {
              match(COMMA);
              {
                switch (LA(1)) {
                  case ID:
                  case LCURLY:
                  case StringLiteral:
                  case LPAREN:
                  case LITERAL_typename:
                  case LITERAL_char:
                  case LITERAL_wchar_t:
                  case LITERAL_bool:
                  case LITERAL_short:
                  case LITERAL_int:
                  case 50:
                  case 51:
                  case 52:
                  case 53:
                  case 54:
                  case 55:
                  case 56:
                  case 57:
                  case 58:
                  case 59:
                  case 60:
                  case 61:
                  case 62:
                  case 63:
                  case 64:
                  case 65:
                  case 66:
                  case 67:
                  case LITERAL_long:
                  case LITERAL_signed:
                  case LITERAL_unsigned:
                  case LITERAL_float:
                  case LITERAL_double:
                  case LITERAL_void:
                  case LITERAL__declspec:
                  case LITERAL___declspec:
                  case OPERATOR:
                  case LITERAL_this:
                  case LITERAL_true:
                  case LITERAL_false:
                  case OCTALINT:
                  case TILDE:
                  case STAR:
                  case AMPERSAND:
                  case PLUS:
                  case MINUS:
                  case PLUSPLUS:
                  case MINUSMINUS:
                  case LITERAL_sizeof:
                  case LITERAL___alignof__:
                  case SCOPE:
                  case LITERAL_dynamic_cast:
                  case LITERAL_static_cast:
                  case LITERAL_reinterpret_cast:
                  case LITERAL_const_cast:
                  case LITERAL_typeid:
                  case DECIMALINT:
                  case HEXADECIMALINT:
                  case CharLiteral:
                  case WCharLiteral:
                  case WStringLiteral:
                  case FLOATONE:
                  case FLOATTWO:
                  case NOT:
                  case LITERAL_new:
                  case LITERAL_delete: {
                    initializer();
                    break;
                  }
                  case RCURLY:
                  case COMMA: {
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
            } else {
              goto _loop248;
            }
          }
        _loop248:;
        }  // ( ... )*
        match(RCURLY);
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_70);
    } else {
      throw;
    }
  }
}

void CPPParser::expression_list() {
  try {  // for error handling
    assignment_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          assignment_expression();
        } else {
          goto _loop592;
        }
      }
    _loop592:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_71);
    } else {
      throw;
    }
  }
}

void CPPParser::remainder_expression() {
  try {  // for error handling
    {
      bool synPredMatched452 = false;
      if (((_tokenSet_72.member(LA(1))) && (_tokenSet_73.member(LA(2))))) {
        int _m452 = mark();
        synPredMatched452 = true;
        inputState->guessing++;
        try {
          {
            conditional_expression();
            {
              switch (LA(1)) {
                case COMMA: {
                  match(COMMA);
                  break;
                }
                case SEMICOLON: {
                  match(SEMICOLON);
                  break;
                }
                case RPAREN: {
                  match(RPAREN);
                  break;
                }
                default: {
                  throw ANTLR_USE_NAMESPACE(antlr)
                      NoViableAltException(LT(1), getFilename());
                }
              }
            }
          }
        } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
          synPredMatched452 = false;
        }
        rewind(_m452);
        inputState->guessing--;
      }
      if (synPredMatched452) {
        if (inputState->guessing == 0) {
#line 1879 "CPP_parser.g"
          assign_stmt_RHS_found += 1;
#line 6400 "CPPParser.cpp"
        }
        assignment_expression();
        if (inputState->guessing == 0) {
#line 1881 "CPP_parser.g"

          if (assign_stmt_RHS_found > 0) {
            assign_stmt_RHS_found -= 1;
          } else {
            fprintf(stderr, "%d warning Error in assign_stmt_RHS_found = %d\n",
                    LT(1)->getLine(), assign_stmt_RHS_found);
            fprintf(stderr, "Press return to continue\n");
            getchar();
          }

#line 6416 "CPPParser.cpp"
        }
      } else if ((_tokenSet_72.member(LA(1))) && (_tokenSet_73.member(LA(2)))) {
        assignment_expression();
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_74);
    } else {
      throw;
    }
  }
}

void CPPParser::member_declarator() {
  try {  // for error handling
    bool synPredMatched257 = false;
    if (((LA(1) == ID || LA(1) == COLON) && (_tokenSet_75.member(LA(2))))) {
      int _m257 = mark();
      synPredMatched257 = true;
      inputState->guessing++;
      try {
        {
          {
            switch (LA(1)) {
              case ID: {
                match(ID);
                break;
              }
              case COLON: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          match(COLON);
          constant_expression();
        }
      } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
        synPredMatched257 = false;
      }
      rewind(_m257);
      inputState->guessing--;
    }
    if (synPredMatched257) {
      {
        switch (LA(1)) {
          case ID: {
            match(ID);
            break;
          }
          case COLON: {
            break;
          }
          default: {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
      }
      match(COLON);
      constant_expression();
    } else if ((_tokenSet_76.member(LA(1))) && (_tokenSet_77.member(LA(2)))) {
      declarator();
    } else {
      throw ANTLR_USE_NAMESPACE(antlr)
          NoViableAltException(LT(1), getFilename());
    }

  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_78);
    } else {
      throw;
    }
  }
}

void CPPParser::ptr_operator() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case AMPERSAND: {
          match(AMPERSAND);
          if (inputState->guessing == 0) {
#line 2198 "CPP_parser.g"
            is_address = true;
#line 6525 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL__cdecl:
        case LITERAL___cdecl: {
          {
            switch (LA(1)) {
              case LITERAL__cdecl: {
                match(LITERAL__cdecl);
                break;
              }
              case LITERAL___cdecl: {
                match(LITERAL___cdecl);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case LITERAL__near:
        case LITERAL___near: {
          {
            switch (LA(1)) {
              case LITERAL__near: {
                match(LITERAL__near);
                break;
              }
              case LITERAL___near: {
                match(LITERAL___near);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case LITERAL__far:
        case LITERAL___far: {
          {
            switch (LA(1)) {
              case LITERAL__far: {
                match(LITERAL__far);
                break;
              }
              case LITERAL___far: {
                match(LITERAL___far);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case LITERAL___interrupt: {
          match(LITERAL___interrupt);
          break;
        }
        case LITERAL_pascal:
        case LITERAL__pascal:
        case LITERAL___pascal: {
          {
            switch (LA(1)) {
              case LITERAL_pascal: {
                match(LITERAL_pascal);
                break;
              }
              case LITERAL__pascal: {
                match(LITERAL__pascal);
                break;
              }
              case LITERAL___pascal: {
                match(LITERAL___pascal);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case LITERAL__stdcall:
        case LITERAL___stdcall: {
          {
            switch (LA(1)) {
              case LITERAL__stdcall: {
                match(LITERAL__stdcall);
                break;
              }
              case LITERAL___stdcall: {
                match(LITERAL___stdcall);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case ID:
        case STAR:
        case SCOPE: {
          ptr_to_member();
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_24);
    } else {
      throw;
    }
  }
}

void CPPParser::direct_declarator() {
  ANTLR_USE_NAMESPACE(antlr)
  RefToken dtor = ANTLR_USE_NAMESPACE(antlr) nullToken;
#line 1225 "CPP_parser.g"
  char* id;
  CPPParser::TypeQualifier tq;
#line 6684 "CPPParser.cpp"

  try {  // for error handling
    switch (LA(1)) {
      case TILDE: {
        match(TILDE);
        dtor = LT(1);
        match(ID);
        if (inputState->guessing == 0) {
#line 1271 "CPP_parser.g"
          declaratorID((dtor->getText()).data(), qiDtor);
#line 6696 "CPPParser.cpp"
        }
        if (inputState->guessing == 0) {
#line 1272 "CPP_parser.g"
          fprintf(
              stderr,
              "%d warning direct_declarator5 entered unexpectedly with %s\n",
              LT(1)->getLine(), (dtor->getText()).data());
#line 6702 "CPPParser.cpp"
        }
        match(LPAREN);
        if (inputState->guessing == 0) {
#line 1274 "CPP_parser.g"
          declaratorParameterList(0);
#line 6708 "CPPParser.cpp"
        }
        {
          switch (LA(1)) {
            case LITERAL_typedef:
            case LITERAL_enum:
            case ID:
            case LITERAL_inline:
            case LITERAL_friend:
            case LITERAL_extern:
            case LITERAL_struct:
            case LITERAL_union:
            case LITERAL_class:
            case LITERAL__stdcall:
            case LITERAL___stdcall:
            case LITERAL_GFEXCLUDE:
            case LITERAL_GFINCLUDE:
            case LITERAL_GFID:
            case LITERAL_GFUNREAD:
            case LITERAL_GFARRAYSIZE:
            case LPAREN:
            case LITERAL_GFARRAYSIZES:
            case LITERAL_GFARRAYELEMSIZE:
            case LITERAL_auto:
            case LITERAL_register:
            case LITERAL_static:
            case LITERAL_mutable:
            case LITERAL__inline:
            case LITERAL___inline:
            case LITERAL_virtual:
            case LITERAL_explicit:
            case LITERAL_typename:
            case LITERAL_char:
            case LITERAL_wchar_t:
            case LITERAL_bool:
            case LITERAL_short:
            case LITERAL_int:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 58:
            case 59:
            case 60:
            case 61:
            case 62:
            case 63:
            case 64:
            case 65:
            case 66:
            case 67:
            case LITERAL_long:
            case LITERAL_signed:
            case LITERAL_unsigned:
            case LITERAL_float:
            case LITERAL_double:
            case LITERAL_void:
            case LITERAL__declspec:
            case LITERAL___declspec:
            case LITERAL_const:
            case LITERAL___const:
            case LITERAL_volatile:
            case LITERAL___volatile__:
            case OPERATOR:
            case LITERAL_this:
            case LITERAL_true:
            case LITERAL_false:
            case TILDE:
            case STAR:
            case AMPERSAND:
            case ELLIPSIS:
            case SCOPE:
            case LITERAL__cdecl:
            case LITERAL___cdecl:
            case LITERAL__near:
            case LITERAL___near:
            case LITERAL__far:
            case LITERAL___far:
            case LITERAL___interrupt:
            case LITERAL_pascal:
            case LITERAL__pascal:
            case LITERAL___pascal: {
              parameter_list();
              break;
            }
            case RPAREN: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
        match(RPAREN);
        if (inputState->guessing == 0) {
#line 1276 "CPP_parser.g"
          declaratorEndParameterList(0);
#line 6812 "CPPParser.cpp"
        }
        break;
      }
      case LPAREN: {
        match(LPAREN);
        declarator();
        match(RPAREN);
        {
          if ((LA(1) == LPAREN || LA(1) == LSQUARE) &&
              (_tokenSet_79.member(LA(2)))) {
            declarator_suffix();
          } else if ((_tokenSet_69.member(LA(1))) &&
                     (_tokenSet_80.member(LA(2)))) {
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        break;
      }
      default:
        bool synPredMatched265 = false;
        if (((_tokenSet_44.member(LA(1))) && (_tokenSet_28.member(LA(2))))) {
          int _m265 = mark();
          synPredMatched265 = true;
          inputState->guessing++;
          try {
            {
              qualified_id();
              match(LPAREN);
              {
                switch (LA(1)) {
                  case RPAREN: {
                    match(RPAREN);
                    break;
                  }
                  case LITERAL_typedef:
                  case LITERAL_enum:
                  case ID:
                  case LITERAL_inline:
                  case LITERAL_friend:
                  case LITERAL_extern:
                  case LITERAL_struct:
                  case LITERAL_union:
                  case LITERAL_class:
                  case LITERAL__stdcall:
                  case LITERAL___stdcall:
                  case LITERAL_GFEXCLUDE:
                  case LITERAL_GFINCLUDE:
                  case LITERAL_GFID:
                  case LITERAL_GFUNREAD:
                  case LITERAL_GFARRAYSIZE:
                  case LITERAL_GFARRAYSIZES:
                  case LITERAL_GFARRAYELEMSIZE:
                  case LITERAL_auto:
                  case LITERAL_register:
                  case LITERAL_static:
                  case LITERAL_mutable:
                  case LITERAL__inline:
                  case LITERAL___inline:
                  case LITERAL_virtual:
                  case LITERAL_explicit:
                  case LITERAL_typename:
                  case LITERAL_char:
                  case LITERAL_wchar_t:
                  case LITERAL_bool:
                  case LITERAL_short:
                  case LITERAL_int:
                  case 50:
                  case 51:
                  case 52:
                  case 53:
                  case 54:
                  case 55:
                  case 56:
                  case 57:
                  case 58:
                  case 59:
                  case 60:
                  case 61:
                  case 62:
                  case 63:
                  case 64:
                  case 65:
                  case 66:
                  case 67:
                  case LITERAL_long:
                  case LITERAL_signed:
                  case LITERAL_unsigned:
                  case LITERAL_float:
                  case LITERAL_double:
                  case LITERAL_void:
                  case LITERAL__declspec:
                  case LITERAL___declspec:
                  case LITERAL_const:
                  case LITERAL___const:
                  case LITERAL_volatile:
                  case LITERAL___volatile__:
                  case SCOPE: {
                    declaration_specifiers();
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
            }
          } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
            synPredMatched265 = false;
          }
          rewind(_m265);
          inputState->guessing--;
        }
        if (synPredMatched265) {
          id = qualified_id();
          if (inputState->guessing == 0) {
#line 1231 "CPP_parser.g"
            if (_td == true) {  // This statement is a typedef
              declaratorID(id, qiType);
            } else {
              declaratorID(id, qiFun);
            }

#line 6941 "CPPParser.cpp"
          }
          match(LPAREN);
          if (inputState->guessing == 0) {
#line 1236 "CPP_parser.g"
            declaratorParameterList(0);
#line 6947 "CPPParser.cpp"
          }
          {
            switch (LA(1)) {
              case LITERAL_typedef:
              case LITERAL_enum:
              case ID:
              case LITERAL_inline:
              case LITERAL_friend:
              case LITERAL_extern:
              case LITERAL_struct:
              case LITERAL_union:
              case LITERAL_class:
              case LITERAL__stdcall:
              case LITERAL___stdcall:
              case LITERAL_GFEXCLUDE:
              case LITERAL_GFINCLUDE:
              case LITERAL_GFID:
              case LITERAL_GFUNREAD:
              case LITERAL_GFARRAYSIZE:
              case LPAREN:
              case LITERAL_GFARRAYSIZES:
              case LITERAL_GFARRAYELEMSIZE:
              case LITERAL_auto:
              case LITERAL_register:
              case LITERAL_static:
              case LITERAL_mutable:
              case LITERAL__inline:
              case LITERAL___inline:
              case LITERAL_virtual:
              case LITERAL_explicit:
              case LITERAL_typename:
              case LITERAL_char:
              case LITERAL_wchar_t:
              case LITERAL_bool:
              case LITERAL_short:
              case LITERAL_int:
              case 50:
              case 51:
              case 52:
              case 53:
              case 54:
              case 55:
              case 56:
              case 57:
              case 58:
              case 59:
              case 60:
              case 61:
              case 62:
              case 63:
              case 64:
              case 65:
              case 66:
              case 67:
              case LITERAL_long:
              case LITERAL_signed:
              case LITERAL_unsigned:
              case LITERAL_float:
              case LITERAL_double:
              case LITERAL_void:
              case LITERAL__declspec:
              case LITERAL___declspec:
              case LITERAL_const:
              case LITERAL___const:
              case LITERAL_volatile:
              case LITERAL___volatile__:
              case OPERATOR:
              case LITERAL_this:
              case LITERAL_true:
              case LITERAL_false:
              case TILDE:
              case STAR:
              case AMPERSAND:
              case ELLIPSIS:
              case SCOPE:
              case LITERAL__cdecl:
              case LITERAL___cdecl:
              case LITERAL__near:
              case LITERAL___near:
              case LITERAL__far:
              case LITERAL___far:
              case LITERAL___interrupt:
              case LITERAL_pascal:
              case LITERAL__pascal:
              case LITERAL___pascal: {
                parameter_list();
                break;
              }
              case RPAREN: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          match(RPAREN);
          if (inputState->guessing == 0) {
#line 1238 "CPP_parser.g"
            declaratorEndParameterList(0);
#line 7051 "CPPParser.cpp"
          }
          {  // ( ... )*
            for (;;) {
              if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) {
                tq = type_qualifier();
              } else {
                goto _loop268;
              }
            }
          _loop268:;
          }  // ( ... )*
          {
            switch (LA(1)) {
              case LITERAL_throw: {
                exception_specification();
                break;
              }
              case GREATERTHAN:
              case SEMICOLON:
              case ASSIGNEQUAL:
              case LPAREN:
              case RPAREN:
              case COMMA:
              case ELLIPSIS: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
        } else {
          bool synPredMatched271 = false;
          if (((_tokenSet_44.member(LA(1))) && (_tokenSet_28.member(LA(2))))) {
            int _m271 = mark();
            synPredMatched271 = true;
            inputState->guessing++;
            try {
              {
                qualified_id();
                match(LPAREN);
                qualified_id();
              }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched271 = false;
            }
            rewind(_m271);
            inputState->guessing--;
          }
          if (synPredMatched271) {
            id = qualified_id();
            if (inputState->guessing == 0) {
#line 1244 "CPP_parser.g"
              declaratorID(id, qiVar);
#line 7113 "CPPParser.cpp"
            }
            match(LPAREN);
            expression_list();
            match(RPAREN);
          } else {
            bool synPredMatched273 = false;
            if (((_tokenSet_44.member(LA(1))) &&
                 (_tokenSet_28.member(LA(2))))) {
              int _m273 = mark();
              synPredMatched273 = true;
              inputState->guessing++;
              try {
                {
                  qualified_id();
                  match(LSQUARE);
                }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched273 = false;
              }
              rewind(_m273);
              inputState->guessing--;
            }
            if (synPredMatched273) {
              id = qualified_id();
              if (inputState->guessing == 0) {
#line 1251 "CPP_parser.g"
                if (_td == true) {           // This statement is a typedef
                  declaratorID(id, qiType);  // This statement is a typedef
                } else {
                  declaratorID(id, qiVar);
                }
                is_address = false;
                is_pointer = false;

#line 7147 "CPPParser.cpp"
              }
              {  // ( ... )+
                int _cnt276 = 0;
                for (;;) {
                  if ((LA(1) == LSQUARE)) {
                    match(LSQUARE);
                    {
                      switch (LA(1)) {
                        case ID:
                        case StringLiteral:
                        case LPAREN:
                        case LITERAL_typename:
                        case LITERAL_char:
                        case LITERAL_wchar_t:
                        case LITERAL_bool:
                        case LITERAL_short:
                        case LITERAL_int:
                        case 50:
                        case 51:
                        case 52:
                        case 53:
                        case 54:
                        case 55:
                        case 56:
                        case 57:
                        case 58:
                        case 59:
                        case 60:
                        case 61:
                        case 62:
                        case 63:
                        case 64:
                        case 65:
                        case 66:
                        case 67:
                        case LITERAL_long:
                        case LITERAL_signed:
                        case LITERAL_unsigned:
                        case LITERAL_float:
                        case LITERAL_double:
                        case LITERAL_void:
                        case LITERAL__declspec:
                        case LITERAL___declspec:
                        case OPERATOR:
                        case LITERAL_this:
                        case LITERAL_true:
                        case LITERAL_false:
                        case OCTALINT:
                        case TILDE:
                        case STAR:
                        case AMPERSAND:
                        case PLUS:
                        case MINUS:
                        case PLUSPLUS:
                        case MINUSMINUS:
                        case LITERAL_sizeof:
                        case LITERAL___alignof__:
                        case SCOPE:
                        case LITERAL_dynamic_cast:
                        case LITERAL_static_cast:
                        case LITERAL_reinterpret_cast:
                        case LITERAL_const_cast:
                        case LITERAL_typeid:
                        case DECIMALINT:
                        case HEXADECIMALINT:
                        case CharLiteral:
                        case WCharLiteral:
                        case WStringLiteral:
                        case FLOATONE:
                        case FLOATTWO:
                        case NOT:
                        case LITERAL_new:
                        case LITERAL_delete: {
                          constant_expression();
                          break;
                        }
                        case RSQUARE: {
                          break;
                        }
                        default: {
                          throw ANTLR_USE_NAMESPACE(antlr)
                              NoViableAltException(LT(1), getFilename());
                        }
                      }
                    }
                    match(RSQUARE);
                  } else {
                    if (_cnt276 >= 1) {
                      goto _loop276;
                    } else {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }

                  _cnt276++;
                }
              _loop276:;
              }  // ( ... )+
              if (inputState->guessing == 0) {
#line 1259 "CPP_parser.g"
                declaratorArray();
#line 7248 "CPPParser.cpp"
              }
            } else if ((_tokenSet_44.member(LA(1))) &&
                       (_tokenSet_81.member(LA(2)))) {
              id = qualified_id();
              if (inputState->guessing == 0) {
#line 1262 "CPP_parser.g"
                if (_td == true) {
                  declaratorID(id, qiType);  // This statement is a typedef
                } else {
                  declaratorID(id, qiVar);
                }
                is_address = false;
                is_pointer = false;

#line 7261 "CPPParser.cpp"
              }
            } else {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_69);
    } else {
      throw;
    }
  }
}

void CPPParser::parameter_list() {
  try {  // for error handling
    parameter_declaration_list();
    {
      switch (LA(1)) {
        case ELLIPSIS: {
          match(ELLIPSIS);
          break;
        }
        case RPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_71);
    } else {
      throw;
    }
  }
}

void CPPParser::exception_specification() {
#line 1560 "CPP_parser.g"
  char* so;
#line 7314 "CPPParser.cpp"

  try {  // for error handling
    match(LITERAL_throw);
    match(LPAREN);
    {
      switch (LA(1)) {
        case ID:
        case RPAREN:
        case SCOPE: {
          {
            switch (LA(1)) {
              case ID:
              case SCOPE: {
                so = scope_override();
                match(ID);
                {  // ( ... )*
                  for (;;) {
                    if ((LA(1) == COMMA)) {
                      match(COMMA);
                      so = scope_override();
                      match(ID);
                    } else {
                      goto _loop366;
                    }
                  }
                _loop366:;
                }  // ( ... )*
                break;
              }
              case RPAREN: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case ELLIPSIS: {
          match(ELLIPSIS);
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(RPAREN);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_82);
    } else {
      throw;
    }
  }
}

void CPPParser::declarator_suffix() {
#line 1284 "CPP_parser.g"
  CPPParser::TypeQualifier tq;
#line 7386 "CPPParser.cpp"

  try {  // for error handling
    {
      if ((LA(1) == LSQUARE)) {
        {  // ( ... )+
          int _cnt283 = 0;
          for (;;) {
            if ((LA(1) == LSQUARE)) {
              match(LSQUARE);
              {
                switch (LA(1)) {
                  case ID:
                  case StringLiteral:
                  case LPAREN:
                  case LITERAL_typename:
                  case LITERAL_char:
                  case LITERAL_wchar_t:
                  case LITERAL_bool:
                  case LITERAL_short:
                  case LITERAL_int:
                  case 50:
                  case 51:
                  case 52:
                  case 53:
                  case 54:
                  case 55:
                  case 56:
                  case 57:
                  case 58:
                  case 59:
                  case 60:
                  case 61:
                  case 62:
                  case 63:
                  case 64:
                  case 65:
                  case 66:
                  case 67:
                  case LITERAL_long:
                  case LITERAL_signed:
                  case LITERAL_unsigned:
                  case LITERAL_float:
                  case LITERAL_double:
                  case LITERAL_void:
                  case LITERAL__declspec:
                  case LITERAL___declspec:
                  case OPERATOR:
                  case LITERAL_this:
                  case LITERAL_true:
                  case LITERAL_false:
                  case OCTALINT:
                  case TILDE:
                  case STAR:
                  case AMPERSAND:
                  case PLUS:
                  case MINUS:
                  case PLUSPLUS:
                  case MINUSMINUS:
                  case LITERAL_sizeof:
                  case LITERAL___alignof__:
                  case SCOPE:
                  case LITERAL_dynamic_cast:
                  case LITERAL_static_cast:
                  case LITERAL_reinterpret_cast:
                  case LITERAL_const_cast:
                  case LITERAL_typeid:
                  case DECIMALINT:
                  case HEXADECIMALINT:
                  case CharLiteral:
                  case WCharLiteral:
                  case WStringLiteral:
                  case FLOATONE:
                  case FLOATTWO:
                  case NOT:
                  case LITERAL_new:
                  case LITERAL_delete: {
                    constant_expression();
                    break;
                  }
                  case RSQUARE: {
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
              match(RSQUARE);
            } else {
              if (_cnt283 >= 1) {
                goto _loop283;
              } else {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }

            _cnt283++;
          }
        _loop283:;
        }  // ( ... )+
        if (inputState->guessing == 0) {
#line 1290 "CPP_parser.g"
          declaratorArray();
#line 7490 "CPPParser.cpp"
        }
      } else if (((LA(1) == LPAREN)) &&
                 ((!((LA(1) == LPAREN) && (LA(2) == ID)) ||
                   (qualifiedItemIsOneOf(qiType | qiCtor, 1))))) {
        match(LPAREN);
        if (inputState->guessing == 0) {
#line 1293 "CPP_parser.g"
          declaratorParameterList(0);
#line 7498 "CPPParser.cpp"
        }
        {
          switch (LA(1)) {
            case LITERAL_typedef:
            case LITERAL_enum:
            case ID:
            case LITERAL_inline:
            case LITERAL_friend:
            case LITERAL_extern:
            case LITERAL_struct:
            case LITERAL_union:
            case LITERAL_class:
            case LITERAL__stdcall:
            case LITERAL___stdcall:
            case LITERAL_GFEXCLUDE:
            case LITERAL_GFINCLUDE:
            case LITERAL_GFID:
            case LITERAL_GFUNREAD:
            case LITERAL_GFARRAYSIZE:
            case LPAREN:
            case LITERAL_GFARRAYSIZES:
            case LITERAL_GFARRAYELEMSIZE:
            case LITERAL_auto:
            case LITERAL_register:
            case LITERAL_static:
            case LITERAL_mutable:
            case LITERAL__inline:
            case LITERAL___inline:
            case LITERAL_virtual:
            case LITERAL_explicit:
            case LITERAL_typename:
            case LITERAL_char:
            case LITERAL_wchar_t:
            case LITERAL_bool:
            case LITERAL_short:
            case LITERAL_int:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 58:
            case 59:
            case 60:
            case 61:
            case 62:
            case 63:
            case 64:
            case 65:
            case 66:
            case 67:
            case LITERAL_long:
            case LITERAL_signed:
            case LITERAL_unsigned:
            case LITERAL_float:
            case LITERAL_double:
            case LITERAL_void:
            case LITERAL__declspec:
            case LITERAL___declspec:
            case LITERAL_const:
            case LITERAL___const:
            case LITERAL_volatile:
            case LITERAL___volatile__:
            case OPERATOR:
            case LITERAL_this:
            case LITERAL_true:
            case LITERAL_false:
            case TILDE:
            case STAR:
            case AMPERSAND:
            case ELLIPSIS:
            case SCOPE:
            case LITERAL__cdecl:
            case LITERAL___cdecl:
            case LITERAL__near:
            case LITERAL___near:
            case LITERAL__far:
            case LITERAL___far:
            case LITERAL___interrupt:
            case LITERAL_pascal:
            case LITERAL__pascal:
            case LITERAL___pascal: {
              parameter_list();
              break;
            }
            case RPAREN: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
        match(RPAREN);
        if (inputState->guessing == 0) {
#line 1295 "CPP_parser.g"
          declaratorEndParameterList(0);
#line 7602 "CPPParser.cpp"
        }
        {  // ( ... )*
          for (;;) {
            if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) {
              tq = type_qualifier();
            } else {
              goto _loop286;
            }
          }
        _loop286:;
        }  // ( ... )*
        {
          switch (LA(1)) {
            case LITERAL_throw: {
              exception_specification();
              break;
            }
            case GREATERTHAN:
            case SEMICOLON:
            case ASSIGNEQUAL:
            case LPAREN:
            case RPAREN:
            case COMMA:
            case ELLIPSIS: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_69);
    } else {
      throw;
    }
  }
}

void CPPParser::template_parameter_list() {
  try {  // for error handling
    if (inputState->guessing == 0) {
#line 1581 "CPP_parser.g"
      beginTemplateParameterList();
#line 7662 "CPPParser.cpp"
    }
    template_parameter();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          template_parameter();
        } else {
          goto _loop370;
        }
      }
    _loop370:;
    }  // ( ... )*
    if (inputState->guessing == 0) {
#line 1583 "CPP_parser.g"
      endTemplateParameterList();
#line 7681 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_52);
    } else {
      throw;
    }
  }
}

void CPPParser::function_direct_declarator(int definition) {
#line 1324 "CPP_parser.g"
  char* q;
  CPPParser::TypeQualifier tq;
#line 7700 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LPAREN: {
          match(LPAREN);
          q = qualified_id();
          if (inputState->guessing == 0) {
#line 1340 "CPP_parser.g"

            declaratorID(q, qiFun);

#line 7714 "CPPParser.cpp"
          }
          match(RPAREN);
          break;
        }
        case ID:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case SCOPE: {
          q = qualified_id();
          if (inputState->guessing == 0) {
#line 1346 "CPP_parser.g"

            declaratorID(q, qiFun);

#line 7732 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    if (inputState->guessing == 0) {
#line 1351 "CPP_parser.g"

#ifdef MYCODE
      if (definition) myCode_function_direct_declarator(q);
#endif  // MYCODE

#line 7750 "CPPParser.cpp"
    }
    match(LPAREN);
    if (inputState->guessing == 0) {
#line 1359 "CPP_parser.g"

      functionParameterList();
      if (K_and_R == false) in_parameter_list = true;

#line 7760 "CPPParser.cpp"
    }
    {
      switch (LA(1)) {
        case LITERAL_typedef:
        case LITERAL_enum:
        case ID:
        case LITERAL_inline:
        case LITERAL_friend:
        case LITERAL_extern:
        case LITERAL_struct:
        case LITERAL_union:
        case LITERAL_class:
        case LITERAL__stdcall:
        case LITERAL___stdcall:
        case LITERAL_GFEXCLUDE:
        case LITERAL_GFINCLUDE:
        case LITERAL_GFID:
        case LITERAL_GFUNREAD:
        case LITERAL_GFARRAYSIZE:
        case LPAREN:
        case LITERAL_GFARRAYSIZES:
        case LITERAL_GFARRAYELEMSIZE:
        case LITERAL_auto:
        case LITERAL_register:
        case LITERAL_static:
        case LITERAL_mutable:
        case LITERAL__inline:
        case LITERAL___inline:
        case LITERAL_virtual:
        case LITERAL_explicit:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case LITERAL_const:
        case LITERAL___const:
        case LITERAL_volatile:
        case LITERAL___volatile__:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case ELLIPSIS:
        case SCOPE:
        case LITERAL__cdecl:
        case LITERAL___cdecl:
        case LITERAL__near:
        case LITERAL___near:
        case LITERAL__far:
        case LITERAL___far:
        case LITERAL___interrupt:
        case LITERAL_pascal:
        case LITERAL__pascal:
        case LITERAL___pascal: {
          parameter_list();
          break;
        }
        case RPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    if (inputState->guessing == 0) {
#line 1365 "CPP_parser.g"

      if (K_and_R == false) {
        in_parameter_list = false;
      } else {
        in_parameter_list = true;
      }

#line 7868 "CPPParser.cpp"
    }
    match(RPAREN);
    {  // ( ... )*
      for (;;) {
        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__)) &&
            (_tokenSet_83.member(LA(2)))) {
          tq = type_qualifier();
        } else {
          goto _loop303;
        }
      }
    _loop303:;
    }  // ( ... )*
    {
      switch (LA(1)) {
        case ASSIGNEQUAL: {
          match(ASSIGNEQUAL);
          match(OCTALINT);
          break;
        }
        case LITERAL_typedef:
        case SEMICOLON:
        case LITERAL_enum:
        case ID:
        case LCURLY:
        case LITERAL_inline:
        case LITERAL_friend:
        case LITERAL_extern:
        case LITERAL_struct:
        case LITERAL_union:
        case LITERAL_class:
        case LITERAL__stdcall:
        case LITERAL___stdcall:
        case LITERAL_GFEXCLUDE:
        case LITERAL_GFINCLUDE:
        case LITERAL_GFID:
        case LITERAL_GFUNREAD:
        case LITERAL_GFARRAYSIZE:
        case LITERAL_GFARRAYSIZES:
        case LITERAL_GFARRAYELEMSIZE:
        case LITERAL_auto:
        case LITERAL_register:
        case LITERAL_static:
        case LITERAL_mutable:
        case LITERAL__inline:
        case LITERAL___inline:
        case LITERAL_virtual:
        case LITERAL_explicit:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case LITERAL_const:
        case LITERAL___const:
        case LITERAL_volatile:
        case LITERAL___volatile__:
        case LITERAL_throw:
        case LITERAL_using:
        case SCOPE: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    if (inputState->guessing == 0) {
#line 1375 "CPP_parser.g"
      functionEndParameterList(definition);
#line 7970 "CPPParser.cpp"
    }
    {
      switch (LA(1)) {
        case LITERAL_throw: {
          exception_specification();
          break;
        }
        case LITERAL_typedef:
        case SEMICOLON:
        case LITERAL_enum:
        case ID:
        case LCURLY:
        case LITERAL_inline:
        case LITERAL_friend:
        case LITERAL_extern:
        case LITERAL_struct:
        case LITERAL_union:
        case LITERAL_class:
        case LITERAL__stdcall:
        case LITERAL___stdcall:
        case LITERAL_GFEXCLUDE:
        case LITERAL_GFINCLUDE:
        case LITERAL_GFID:
        case LITERAL_GFUNREAD:
        case LITERAL_GFARRAYSIZE:
        case LITERAL_GFARRAYSIZES:
        case LITERAL_GFARRAYELEMSIZE:
        case LITERAL_auto:
        case LITERAL_register:
        case LITERAL_static:
        case LITERAL_mutable:
        case LITERAL__inline:
        case LITERAL___inline:
        case LITERAL_virtual:
        case LITERAL_explicit:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case LITERAL_const:
        case LITERAL___const:
        case LITERAL_volatile:
        case LITERAL___volatile__:
        case LITERAL_using:
        case SCOPE: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_29);
    } else {
      throw;
    }
  }
}

void CPPParser::ctor_head() {
  try {  // for error handling
    ctor_decl_spec();
    ctor_declarator(1);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_84);
    } else {
      throw;
    }
  }
}

void CPPParser::ctor_body() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case COLON: {
          ctor_initializer();
          break;
        }
        case LCURLY: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    compound_statement();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_30);
    } else {
      throw;
    }
  }
}

char* CPPParser::qualified_ctor_id() {
#line 1414 "CPP_parser.g"
  char* q = NULL;
#line 8116 "CPPParser.cpp"
  ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken;
#line 1414 "CPP_parser.g"

  char* so;
  static char qitem[CPPParser_MaxQualifiedItemSize + 1];

#line 8123 "CPPParser.cpp"

  try {  // for error handling
    so = scope_override();
    if (inputState->guessing == 0) {
#line 1421 "CPP_parser.g"
      strcpy(qitem, so);
#line 8130 "CPPParser.cpp"
    }
    id = LT(1);
    match(ID);
    if (inputState->guessing == 0) {
#line 1423 "CPP_parser.g"
      strcat(qitem, (id->getText()).data());
      q = qitem;
#line 8138 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_85);
    } else {
      throw;
    }
  }
  return q;
}

void CPPParser::ctor_initializer() {
  try {  // for error handling
    match(COLON);
    superclass_init();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == COMMA)) {
          match(COMMA);
          superclass_init();
        } else {
          goto _loop320;
        }
      }
    _loop320:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_53);
    } else {
      throw;
    }
  }
}

void CPPParser::superclass_init() {
#line 1441 "CPP_parser.g"
  char* q;
#line 8184 "CPPParser.cpp"

  try {  // for error handling
    q = qualified_id();
    match(LPAREN);
    {
      switch (LA(1)) {
        case ID:
        case StringLiteral:
        case LPAREN:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case OCTALINT:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case PLUS:
        case MINUS:
        case PLUSPLUS:
        case MINUSMINUS:
        case LITERAL_sizeof:
        case LITERAL___alignof__:
        case SCOPE:
        case LITERAL_dynamic_cast:
        case LITERAL_static_cast:
        case LITERAL_reinterpret_cast:
        case LITERAL_const_cast:
        case LITERAL_typeid:
        case DECIMALINT:
        case HEXADECIMALINT:
        case CharLiteral:
        case WCharLiteral:
        case WStringLiteral:
        case FLOATONE:
        case FLOATTWO:
        case NOT:
        case LITERAL_new:
        case LITERAL_delete: {
          expression_list();
          break;
        }
        case RPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(RPAREN);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_60);
    } else {
      throw;
    }
  }
}

void CPPParser::dtor_decl_spec() {
  try {  // for error handling
    {    // ( ... )*
      for (;;) {
        switch (LA(1)) {
          case LITERAL_inline:
          case LITERAL__inline:
          case LITERAL___inline: {
            {
              switch (LA(1)) {
                case LITERAL_inline: {
                  match(LITERAL_inline);
                  break;
                }
                case LITERAL__inline: {
                  match(LITERAL__inline);
                  break;
                }
                case LITERAL___inline: {
                  match(LITERAL___inline);
                  break;
                }
                default: {
                  throw ANTLR_USE_NAMESPACE(antlr)
                      NoViableAltException(LT(1), getFilename());
                }
              }
            }
            break;
          }
          case LITERAL_virtual: {
            match(LITERAL_virtual);
            break;
          }
          default: { goto _loop327; }
        }
      }
    _loop327:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_86);
    } else {
      throw;
    }
  }
}

void CPPParser::dtor_declarator(int definition) {
#line 1461 "CPP_parser.g"
  char* s;
#line 8346 "CPPParser.cpp"

  try {  // for error handling
    s = scope_override();
    match(TILDE);
    match(ID);
    if (inputState->guessing == 0) {
#line 1466 "CPP_parser.g"
      declaratorParameterList(definition);
#line 8355 "CPPParser.cpp"
    }
    match(LPAREN);
    {
      switch (LA(1)) {
        case LITERAL_void: {
          match(LITERAL_void);
          break;
        }
        case RPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(RPAREN);
    if (inputState->guessing == 0) {
#line 1468 "CPP_parser.g"
      declaratorEndParameterList(definition);
#line 8379 "CPPParser.cpp"
    }
    {
      switch (LA(1)) {
        case LITERAL_throw: {
          exception_specification();
          break;
        }
        case SEMICOLON:
        case LCURLY: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_32);
    } else {
      throw;
    }
  }
}

void CPPParser::parameter_declaration_list() {
  try {  // for error handling
    {
      parameter_declaration();
      {  // ( ... )*
        for (;;) {
          if ((LA(1) == COMMA)) {
            match(COMMA);
            parameter_declaration();
          } else {
            goto _loop337;
          }
        }
      _loop337:;
      }  // ( ... )*
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_87);
    } else {
      throw;
    }
  }
}

void CPPParser::parameter_declaration() {
  try {  // for error handling
    if (inputState->guessing == 0) {
#line 1494 "CPP_parser.g"
      beginParameterDeclaration();
#line 8446 "CPPParser.cpp"
    }
    {
      if (((_tokenSet_12.member(LA(1))) && (_tokenSet_88.member(LA(2)))) &&
          (!((LA(1) == SCOPE) && (LA(2) == STAR || LA(2) == OPERATOR)) &&
           (!(LA(1) == SCOPE || LA(1) == ID) ||
            qualifiedItemIsOneOf(qiType | qiCtor)))) {
        declaration_specifiers();
        {
          bool synPredMatched342 = false;
          if (((_tokenSet_76.member(LA(1))) && (_tokenSet_89.member(LA(2))))) {
            int _m342 = mark();
            synPredMatched342 = true;
            inputState->guessing++;
            try {
              { declarator(); }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched342 = false;
            }
            rewind(_m342);
            inputState->guessing--;
          }
          if (synPredMatched342) {
            declarator();
          } else if ((_tokenSet_90.member(LA(1))) &&
                     (_tokenSet_91.member(LA(2)))) {
            abstract_declarator();
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
      } else {
        bool synPredMatched344 = false;
        if (((_tokenSet_76.member(LA(1))) && (_tokenSet_89.member(LA(2))))) {
          int _m344 = mark();
          synPredMatched344 = true;
          inputState->guessing++;
          try {
            { declarator(); }
          } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
            synPredMatched344 = false;
          }
          rewind(_m344);
          inputState->guessing--;
        }
        if (synPredMatched344) {
          declarator();
        } else if ((LA(1) == ELLIPSIS)) {
          match(ELLIPSIS);
        } else {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    {
      switch (LA(1)) {
        case ASSIGNEQUAL: {
          match(ASSIGNEQUAL);
          remainder_expression();
          break;
        }
        case GREATERTHAN:
        case RPAREN:
        case COMMA:
        case ELLIPSIS: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_92);
    } else {
      throw;
    }
  }
}

void CPPParser::abstract_declarator() {
  try {  // for error handling
    if ((_tokenSet_25.member(LA(1)))) {
      ptr_operator();
      abstract_declarator();
    } else {
      bool synPredMatched351 = false;
      if (((LA(1) == LPAREN) && (_tokenSet_25.member(LA(2))))) {
        int _m351 = mark();
        synPredMatched351 = true;
        inputState->guessing++;
        try {
          {
            match(LPAREN);
            {  // ( ... )+
              int _cnt350 = 0;
              for (;;) {
                if ((_tokenSet_25.member(LA(1)))) {
                  ptr_operator();
                } else {
                  if (_cnt350 >= 1) {
                    goto _loop350;
                  } else {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }

                _cnt350++;
              }
            _loop350:;
            }  // ( ... )+
            match(RPAREN);
          }
        } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
          synPredMatched351 = false;
        }
        rewind(_m351);
        inputState->guessing--;
      }
      if (synPredMatched351) {
        match(LPAREN);
        {  // ( ... )+
          int _cnt353 = 0;
          for (;;) {
            if ((_tokenSet_25.member(LA(1)))) {
              ptr_operator();
            } else {
              if (_cnt353 >= 1) {
                goto _loop353;
              } else {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }

            _cnt353++;
          }
        _loop353:;
        }  // ( ... )+
        match(RPAREN);
        {
          switch (LA(1)) {
            case LPAREN:
            case LSQUARE: {
              abstract_declarator_suffix();
              break;
            }
            case GREATERTHAN:
            case ASSIGNEQUAL:
            case RPAREN:
            case COMMA:
            case ELLIPSIS: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
      } else if ((_tokenSet_93.member(LA(1))) && (_tokenSet_94.member(LA(2)))) {
        {
          switch (LA(1)) {
            case LPAREN:
            case LSQUARE: {
              abstract_declarator_suffix();
              break;
            }
            case GREATERTHAN:
            case ASSIGNEQUAL:
            case RPAREN:
            case COMMA:
            case ELLIPSIS: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_95);
    } else {
      throw;
    }
  }
}

void CPPParser::type_id() {
  try {  // for error handling
    declaration_specifiers();
    abstract_declarator();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_96);
    } else {
      throw;
    }
  }
}

void CPPParser::abstract_declarator_suffix() {
  try {  // for error handling
    switch (LA(1)) {
      case LSQUARE: {
        {  // ( ... )+
          int _cnt359 = 0;
          for (;;) {
            if ((LA(1) == LSQUARE)) {
              match(LSQUARE);
              {
                switch (LA(1)) {
                  case ID:
                  case StringLiteral:
                  case LPAREN:
                  case LITERAL_typename:
                  case LITERAL_char:
                  case LITERAL_wchar_t:
                  case LITERAL_bool:
                  case LITERAL_short:
                  case LITERAL_int:
                  case 50:
                  case 51:
                  case 52:
                  case 53:
                  case 54:
                  case 55:
                  case 56:
                  case 57:
                  case 58:
                  case 59:
                  case 60:
                  case 61:
                  case 62:
                  case 63:
                  case 64:
                  case 65:
                  case 66:
                  case 67:
                  case LITERAL_long:
                  case LITERAL_signed:
                  case LITERAL_unsigned:
                  case LITERAL_float:
                  case LITERAL_double:
                  case LITERAL_void:
                  case LITERAL__declspec:
                  case LITERAL___declspec:
                  case OPERATOR:
                  case LITERAL_this:
                  case LITERAL_true:
                  case LITERAL_false:
                  case OCTALINT:
                  case TILDE:
                  case STAR:
                  case AMPERSAND:
                  case PLUS:
                  case MINUS:
                  case PLUSPLUS:
                  case MINUSMINUS:
                  case LITERAL_sizeof:
                  case LITERAL___alignof__:
                  case SCOPE:
                  case LITERAL_dynamic_cast:
                  case LITERAL_static_cast:
                  case LITERAL_reinterpret_cast:
                  case LITERAL_const_cast:
                  case LITERAL_typeid:
                  case DECIMALINT:
                  case HEXADECIMALINT:
                  case CharLiteral:
                  case WCharLiteral:
                  case WStringLiteral:
                  case FLOATONE:
                  case FLOATTWO:
                  case NOT:
                  case LITERAL_new:
                  case LITERAL_delete: {
                    constant_expression();
                    break;
                  }
                  case RSQUARE: {
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
              match(RSQUARE);
            } else {
              if (_cnt359 >= 1) {
                goto _loop359;
              } else {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }

            _cnt359++;
          }
        _loop359:;
        }  // ( ... )+
        if (inputState->guessing == 0) {
#line 1548 "CPP_parser.g"
          declaratorArray();
#line 8780 "CPPParser.cpp"
        }
        break;
      }
      case LPAREN: {
        match(LPAREN);
        if (inputState->guessing == 0) {
#line 1551 "CPP_parser.g"
          declaratorParameterList(0);
#line 8790 "CPPParser.cpp"
        }
        {
          switch (LA(1)) {
            case LITERAL_typedef:
            case LITERAL_enum:
            case ID:
            case LITERAL_inline:
            case LITERAL_friend:
            case LITERAL_extern:
            case LITERAL_struct:
            case LITERAL_union:
            case LITERAL_class:
            case LITERAL__stdcall:
            case LITERAL___stdcall:
            case LITERAL_GFEXCLUDE:
            case LITERAL_GFINCLUDE:
            case LITERAL_GFID:
            case LITERAL_GFUNREAD:
            case LITERAL_GFARRAYSIZE:
            case LPAREN:
            case LITERAL_GFARRAYSIZES:
            case LITERAL_GFARRAYELEMSIZE:
            case LITERAL_auto:
            case LITERAL_register:
            case LITERAL_static:
            case LITERAL_mutable:
            case LITERAL__inline:
            case LITERAL___inline:
            case LITERAL_virtual:
            case LITERAL_explicit:
            case LITERAL_typename:
            case LITERAL_char:
            case LITERAL_wchar_t:
            case LITERAL_bool:
            case LITERAL_short:
            case LITERAL_int:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 58:
            case 59:
            case 60:
            case 61:
            case 62:
            case 63:
            case 64:
            case 65:
            case 66:
            case 67:
            case LITERAL_long:
            case LITERAL_signed:
            case LITERAL_unsigned:
            case LITERAL_float:
            case LITERAL_double:
            case LITERAL_void:
            case LITERAL__declspec:
            case LITERAL___declspec:
            case LITERAL_const:
            case LITERAL___const:
            case LITERAL_volatile:
            case LITERAL___volatile__:
            case OPERATOR:
            case LITERAL_this:
            case LITERAL_true:
            case LITERAL_false:
            case TILDE:
            case STAR:
            case AMPERSAND:
            case ELLIPSIS:
            case SCOPE:
            case LITERAL__cdecl:
            case LITERAL___cdecl:
            case LITERAL__near:
            case LITERAL___near:
            case LITERAL__far:
            case LITERAL___far:
            case LITERAL___interrupt:
            case LITERAL_pascal:
            case LITERAL__pascal:
            case LITERAL___pascal: {
              parameter_list();
              break;
            }
            case RPAREN: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
        match(RPAREN);
        if (inputState->guessing == 0) {
#line 1554 "CPP_parser.g"
          declaratorEndParameterList(0);
#line 8894 "CPPParser.cpp"
        }
        cv_qualifier_seq();
        {
          switch (LA(1)) {
            case LITERAL_throw: {
              exception_specification();
              break;
            }
            case GREATERTHAN:
            case ASSIGNEQUAL:
            case RPAREN:
            case COMMA:
            case ELLIPSIS: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_95);
    } else {
      throw;
    }
  }
}

void CPPParser::cv_qualifier_seq() {
#line 2218 "CPP_parser.g"
  CPPParser::TypeQualifier tq;
#line 8939 "CPPParser.cpp"

  try {  // for error handling
    {    // ( ... )*
      for (;;) {
        if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) {
          tq = type_qualifier();
        } else {
          goto _loop581;
        }
      }
    _loop581:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_97);
    } else {
      throw;
    }
  }
}

void CPPParser::template_parameter() {
  try {  // for error handling
    {
      if ((_tokenSet_98.member(LA(1))) && (_tokenSet_99.member(LA(2)))) {
        type_parameter();
      } else if ((_tokenSet_100.member(LA(1))) &&
                 (_tokenSet_15.member(LA(2)))) {
        parameter_declaration();
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_101);
    } else {
      throw;
    }
  }
}

void CPPParser::type_parameter() {
  ANTLR_USE_NAMESPACE(antlr) RefToken id = ANTLR_USE_NAMESPACE(antlr) nullToken;
  ANTLR_USE_NAMESPACE(antlr)
  RefToken id2 = ANTLR_USE_NAMESPACE(antlr) nullToken;

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_class:
        case LITERAL_typename: {
          {
            switch (LA(1)) {
              case LITERAL_class: {
                match(LITERAL_class);
                break;
              }
              case LITERAL_typename: {
                match(LITERAL_typename);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          {
            switch (LA(1)) {
              case ID: {
                id = LT(1);
                match(ID);
                if (inputState->guessing == 0) {
#line 1610 "CPP_parser.g"

                  templateTypeParameter((id->getText()).data());

#line 9030 "CPPParser.cpp"
                }
                {
                  switch (LA(1)) {
                    case ASSIGNEQUAL: {
                      match(ASSIGNEQUAL);
                      assigned_type_name();
                      break;
                    }
                    case GREATERTHAN:
                    case COMMA: {
                      break;
                    }
                    default: {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }
                }
                break;
              }
              case GREATERTHAN:
              case COMMA: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        case LITERAL_template: {
          template_head();
          match(LITERAL_class);
          {
            switch (LA(1)) {
              case ID: {
                id2 = LT(1);
                match(ID);
                if (inputState->guessing == 0) {
#line 1618 "CPP_parser.g"

                  templateTypeParameter((id2->getText()).data());

#line 9081 "CPPParser.cpp"
                }
                {
                  switch (LA(1)) {
                    case ASSIGNEQUAL: {
                      match(ASSIGNEQUAL);
                      assigned_type_name();
                      break;
                    }
                    case GREATERTHAN:
                    case COMMA: {
                      break;
                    }
                    default: {
                      throw ANTLR_USE_NAMESPACE(antlr)
                          NoViableAltException(LT(1), getFilename());
                    }
                  }
                }
                break;
              }
              case GREATERTHAN:
              case COMMA: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_101);
    } else {
      throw;
    }
  }
}

void CPPParser::assigned_type_name() {
#line 1631 "CPP_parser.g"
  char* qt;
  TypeSpecifier ts;
#line 9137 "CPPParser.cpp"

  try {  // for error handling
    {
      if ((LA(1) == ID || LA(1) == SCOPE) && (_tokenSet_102.member(LA(2)))) {
        qt = qualified_type();
        abstract_declarator();
      } else if ((_tokenSet_103.member(LA(1))) &&
                 (_tokenSet_104.member(LA(2)))) {
        ts = simple_type_specifier();
        abstract_declarator();
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_101);
    } else {
      throw;
    }
  }
}

void CPPParser::template_id() {
  try {  // for error handling
    match(ID);
    match(LESSTHAN);
    template_argument_list();
    match(GREATERTHAN);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_1);
    } else {
      throw;
    }
  }
}

void CPPParser::template_argument() {
  try {  // for error handling
    if (((_tokenSet_12.member(LA(1))) && (_tokenSet_105.member(LA(2)))) &&
        ((!(LA(1) == SCOPE || LA(1) == ID) ||
          qualifiedItemIsOneOf(qiType | qiCtor)))) {
      type_id();
    } else if ((_tokenSet_72.member(LA(1))) && (_tokenSet_106.member(LA(2)))) {
      shift_expression();
    } else {
      throw ANTLR_USE_NAMESPACE(antlr)
          NoViableAltException(LT(1), getFilename());
    }

  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_101);
    } else {
      throw;
    }
  }
}

void CPPParser::shift_expression() {
  try {  // for error handling
    additive_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == SHIFTLEFT || LA(1) == SHIFTRIGHT)) {
          {
            switch (LA(1)) {
              case SHIFTLEFT: {
                match(SHIFTLEFT);
                break;
              }
              case SHIFTRIGHT: {
                match(SHIFTRIGHT);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          additive_expression();
        } else {
          goto _loop482;
        }
      }
    _loop482:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_107);
    } else {
      throw;
    }
  }
}

void CPPParser::statement_list() {
  try {  // for error handling
    {    // ( ... )+
      int _cnt389 = 0;
      for (;;) {
        if ((_tokenSet_49.member(LA(1)))) {
          statement();
        } else {
          if (_cnt389 >= 1) {
            goto _loop389;
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }

        _cnt389++;
      }
    _loop389:;
    }  // ( ... )+
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_61);
    } else {
      throw;
    }
  }
}

void CPPParser::statement() {
#line 1680 "CPP_parser.g"

  FunctionSpecifier fs = fsInvalid;  // inline,virtual,explicit

#line 9285 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_case: {
          case_statement();
          break;
        }
        case LITERAL_default: {
          default_statement();
          break;
        }
        case LCURLY: {
          compound_statement();
          break;
        }
        case LITERAL_if:
        case LITERAL_switch: {
          selection_statement();
          break;
        }
        case LITERAL_while:
        case LITERAL_do:
        case LITERAL_for: {
          iteration_statement();
          break;
        }
        case LITERAL_goto:
        case LITERAL_continue:
        case LITERAL_break:
        case LITERAL_return: {
          jump_statement();
          break;
        }
        case LITERAL_try: {
          try_block();
          break;
        }
        case LITERAL_throw: {
          throw_statement();
          break;
        }
        default:
          bool synPredMatched393 = false;
          if (((_tokenSet_108.member(LA(1))) &&
               (_tokenSet_109.member(LA(2))))) {
            int _m393 = mark();
            synPredMatched393 = true;
            inputState->guessing++;
            try {
              {
                switch (LA(1)) {
                  case LITERAL_namespace: {
                    match(LITERAL_namespace);
                    break;
                  }
                  case LITERAL_using: {
                    match(LITERAL_using);
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched393 = false;
            }
            rewind(_m393);
            inputState->guessing--;
          }
          if (synPredMatched393) {
            block_declaration();
          } else {
            bool synPredMatched397 = false;
            if (((_tokenSet_20.member(LA(1))) &&
                 (_tokenSet_110.member(LA(2))))) {
              int _m397 = mark();
              synPredMatched397 = true;
              inputState->guessing++;
              try {
                {
                  {
                    switch (LA(1)) {
                      case LITERAL_typedef: {
                        match(LITERAL_typedef);
                        break;
                      }
                      case LITERAL_struct:
                      case LITERAL_union:
                      case LITERAL_class: {
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  class_specifier();
                  {
                    switch (LA(1)) {
                      case ID:
                      case OPERATOR:
                      case LITERAL_this:
                      case LITERAL_true:
                      case LITERAL_false:
                      case SCOPE: {
                        qualified_id();
                        break;
                      }
                      case LCURLY: {
                        break;
                      }
                      default: {
                        throw ANTLR_USE_NAMESPACE(antlr)
                            NoViableAltException(LT(1), getFilename());
                      }
                    }
                  }
                  match(LCURLY);
                }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched397 = false;
              }
              rewind(_m397);
              inputState->guessing--;
            }
            if (synPredMatched397) {
              member_declaration();
            } else {
              bool synPredMatched399 = false;
              if (((_tokenSet_20.member(LA(1))) &&
                   (_tokenSet_110.member(LA(2))))) {
                int _m399 = mark();
                synPredMatched399 = true;
                inputState->guessing++;
                try {
                  {
                    declaration_specifiers();
                    match(LPAREN);
                    ptr_operator();
                    qualified_id();
                    match(RPAREN);
                  }
                } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                  synPredMatched399 = false;
                }
                rewind(_m399);
                inputState->guessing--;
              }
              if (synPredMatched399) {
                member_declaration();
              } else {
                bool synPredMatched402 = false;
                if (((_tokenSet_20.member(LA(1))) &&
                     (_tokenSet_110.member(LA(2))))) {
                  int _m402 = mark();
                  synPredMatched402 = true;
                  inputState->guessing++;
                  try {
                    {
                      declaration_specifiers();
                      {
                        ptr_operator();
                        ptr_operator();
                      }
                      qualified_id();
                    }
                  } catch (ANTLR_USE_NAMESPACE(antlr)
                               RecognitionException& pe) {
                    synPredMatched402 = false;
                  }
                  rewind(_m402);
                  inputState->guessing--;
                }
                if (synPredMatched402) {
                  member_declaration();
                } else {
                  bool synPredMatched407 = false;
                  if (((_tokenSet_20.member(LA(1))) &&
                       (_tokenSet_110.member(LA(2))))) {
                    int _m407 = mark();
                    synPredMatched407 = true;
                    inputState->guessing++;
                    try {
                      {
                        declaration_specifiers();
                        {
                          bool synPredMatched406 = false;
                          if (((_tokenSet_25.member(LA(1))) &&
                               (_tokenSet_111.member(LA(2))))) {
                            int _m406 = mark();
                            synPredMatched406 = true;
                            inputState->guessing++;
                            try {
                              { ptr_operator(); }
                            } catch (ANTLR_USE_NAMESPACE(antlr)
                                         RecognitionException& pe) {
                              synPredMatched406 = false;
                            }
                            rewind(_m406);
                            inputState->guessing--;
                          }
                          if (synPredMatched406) {
                            ptr_operator();
                          } else if ((_tokenSet_44.member(LA(1))) && (true)) {
                          } else {
                            throw ANTLR_USE_NAMESPACE(antlr)
                                NoViableAltException(LT(1), getFilename());
                          }
                        }
                        qualified_id();
                      }
                    } catch (ANTLR_USE_NAMESPACE(antlr)
                                 RecognitionException& pe) {
                      synPredMatched407 = false;
                    }
                    rewind(_m407);
                    inputState->guessing--;
                  }
                  if (synPredMatched407) {
                    member_declaration();
                  } else if ((LA(1) == ID) && (LA(2) == COLON)) {
                    labeled_statement();
                  } else if ((_tokenSet_72.member(LA(1))) &&
                             (_tokenSet_112.member(LA(2)))) {
                    expression();
                    match(SEMICOLON);
                    if (inputState->guessing == 0) {
#line 1698 "CPP_parser.g"
                      end_of_stmt();
#line 9539 "CPPParser.cpp"
                    }
                  } else if ((LA(1) == SEMICOLON) &&
                             (_tokenSet_40.member(LA(2)))) {
                    match(SEMICOLON);
                    if (inputState->guessing == 0) {
#line 1703 "CPP_parser.g"
                      end_of_stmt();
#line 9547 "CPPParser.cpp"
                    }
                  } else if ((LA(1) == LITERAL_antlrTrace_on) &&
                             (_tokenSet_40.member(LA(2)))) {
                    match(LITERAL_antlrTrace_on);
                    if (inputState->guessing == 0) {
#line 1708 "CPP_parser.g"
                      antlrTrace(true);
#line 9555 "CPPParser.cpp"
                    }
                  } else if ((LA(1) == LITERAL_antlrTrace_off) &&
                             (_tokenSet_40.member(LA(2)))) {
                    match(LITERAL_antlrTrace_off);
                    if (inputState->guessing == 0) {
#line 1710 "CPP_parser.g"
                      antlrTrace(false);
#line 9563 "CPPParser.cpp"
                    }
                  } else {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
            }
          }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::block_declaration() {
  try {  // for error handling
    switch (LA(1)) {
      case LITERAL_typedef:
      case LITERAL_enum:
      case ID:
      case LITERAL_inline:
      case LITERAL_friend:
      case LITERAL_extern:
      case LITERAL_struct:
      case LITERAL_union:
      case LITERAL_class:
      case LITERAL__stdcall:
      case LITERAL___stdcall:
      case LITERAL_GFEXCLUDE:
      case LITERAL_GFINCLUDE:
      case LITERAL_GFID:
      case LITERAL_GFUNREAD:
      case LITERAL_GFARRAYSIZE:
      case LITERAL_GFARRAYSIZES:
      case LITERAL_GFARRAYELEMSIZE:
      case LITERAL_auto:
      case LITERAL_register:
      case LITERAL_static:
      case LITERAL_mutable:
      case LITERAL__inline:
      case LITERAL___inline:
      case LITERAL_virtual:
      case LITERAL_explicit:
      case LITERAL_typename:
      case LITERAL_char:
      case LITERAL_wchar_t:
      case LITERAL_bool:
      case LITERAL_short:
      case LITERAL_int:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 58:
      case 59:
      case 60:
      case 61:
      case 62:
      case 63:
      case 64:
      case 65:
      case 66:
      case 67:
      case LITERAL_long:
      case LITERAL_signed:
      case LITERAL_unsigned:
      case LITERAL_float:
      case LITERAL_double:
      case LITERAL_void:
      case LITERAL__declspec:
      case LITERAL___declspec:
      case LITERAL_const:
      case LITERAL___const:
      case LITERAL_volatile:
      case LITERAL___volatile__:
      case SCOPE: {
        simple_declaration();
        break;
      }
      case LITERAL_asm:
      case LITERAL__asm:
      case LITERAL___asm:
      case LITERAL___asm__: {
        asm_definition();
        break;
      }
      case LITERAL_namespace: {
        namespace_alias_definition();
        break;
      }
      case LITERAL_using: {
        using_statement();
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::labeled_statement() {
  try {  // for error handling
    match(ID);
    match(COLON);
    statement();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::case_statement() {
  try {  // for error handling
    match(LITERAL_case);
    constant_expression();
    match(COLON);
    statement();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::default_statement() {
  try {  // for error handling
    match(LITERAL_default);
    match(COLON);
    statement();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::selection_statement() {
  try {  // for error handling
    switch (LA(1)) {
      case LITERAL_if: {
        match(LITERAL_if);
        match(LPAREN);
        expression();
        match(RPAREN);
        statement();
        {
          if ((LA(1) == LITERAL_else) && (_tokenSet_49.member(LA(2)))) {
            match(LITERAL_else);
            statement();
          } else if ((_tokenSet_40.member(LA(1))) &&
                     (_tokenSet_113.member(LA(2)))) {
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        break;
      }
      case LITERAL_switch: {
        match(LITERAL_switch);
        match(LPAREN);
        expression();
        match(RPAREN);
        statement();
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::iteration_statement() {
  try {  // for error handling
    switch (LA(1)) {
      case LITERAL_while: {
        match(LITERAL_while);
        match(LPAREN);
        expression();
        match(RPAREN);
        statement();
        break;
      }
      case LITERAL_do: {
        match(LITERAL_do);
        statement();
        match(LITERAL_while);
        match(LPAREN);
        expression();
        match(RPAREN);
        match(SEMICOLON);
        if (inputState->guessing == 0) {
#line 1777 "CPP_parser.g"
          end_of_stmt();
#line 9814 "CPPParser.cpp"
        }
        break;
      }
      case LITERAL_for: {
        match(LITERAL_for);
        match(LPAREN);
        {
          bool synPredMatched421 = false;
          if (((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2))))) {
            int _m421 = mark();
            synPredMatched421 = true;
            inputState->guessing++;
            try {
              { declaration(); }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched421 = false;
            }
            rewind(_m421);
            inputState->guessing--;
          }
          if (synPredMatched421) {
            declaration();
          } else if ((_tokenSet_72.member(LA(1))) &&
                     (_tokenSet_112.member(LA(2)))) {
            expression();
            match(SEMICOLON);
            if (inputState->guessing == 0) {
#line 1781 "CPP_parser.g"
              end_of_stmt();
#line 9848 "CPPParser.cpp"
            }
          } else if ((LA(1) == SEMICOLON)) {
            match(SEMICOLON);
            if (inputState->guessing == 0) {
#line 1782 "CPP_parser.g"
              end_of_stmt();
#line 9856 "CPPParser.cpp"
            }
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        {
          switch (LA(1)) {
            case ID:
            case StringLiteral:
            case LPAREN:
            case LITERAL_typename:
            case LITERAL_char:
            case LITERAL_wchar_t:
            case LITERAL_bool:
            case LITERAL_short:
            case LITERAL_int:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 58:
            case 59:
            case 60:
            case 61:
            case 62:
            case 63:
            case 64:
            case 65:
            case 66:
            case 67:
            case LITERAL_long:
            case LITERAL_signed:
            case LITERAL_unsigned:
            case LITERAL_float:
            case LITERAL_double:
            case LITERAL_void:
            case LITERAL__declspec:
            case LITERAL___declspec:
            case OPERATOR:
            case LITERAL_this:
            case LITERAL_true:
            case LITERAL_false:
            case OCTALINT:
            case TILDE:
            case STAR:
            case AMPERSAND:
            case PLUS:
            case MINUS:
            case PLUSPLUS:
            case MINUSMINUS:
            case LITERAL_sizeof:
            case LITERAL___alignof__:
            case SCOPE:
            case LITERAL_dynamic_cast:
            case LITERAL_static_cast:
            case LITERAL_reinterpret_cast:
            case LITERAL_const_cast:
            case LITERAL_typeid:
            case DECIMALINT:
            case HEXADECIMALINT:
            case CharLiteral:
            case WCharLiteral:
            case WStringLiteral:
            case FLOATONE:
            case FLOATTWO:
            case NOT:
            case LITERAL_new:
            case LITERAL_delete: {
              expression();
              break;
            }
            case SEMICOLON: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
        match(SEMICOLON);
        if (inputState->guessing == 0) {
#line 1784 "CPP_parser.g"
          end_of_stmt();
#line 9949 "CPPParser.cpp"
        }
        {
          switch (LA(1)) {
            case ID:
            case StringLiteral:
            case LPAREN:
            case LITERAL_typename:
            case LITERAL_char:
            case LITERAL_wchar_t:
            case LITERAL_bool:
            case LITERAL_short:
            case LITERAL_int:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 58:
            case 59:
            case 60:
            case 61:
            case 62:
            case 63:
            case 64:
            case 65:
            case 66:
            case 67:
            case LITERAL_long:
            case LITERAL_signed:
            case LITERAL_unsigned:
            case LITERAL_float:
            case LITERAL_double:
            case LITERAL_void:
            case LITERAL__declspec:
            case LITERAL___declspec:
            case OPERATOR:
            case LITERAL_this:
            case LITERAL_true:
            case LITERAL_false:
            case OCTALINT:
            case TILDE:
            case STAR:
            case AMPERSAND:
            case PLUS:
            case MINUS:
            case PLUSPLUS:
            case MINUSMINUS:
            case LITERAL_sizeof:
            case LITERAL___alignof__:
            case SCOPE:
            case LITERAL_dynamic_cast:
            case LITERAL_static_cast:
            case LITERAL_reinterpret_cast:
            case LITERAL_const_cast:
            case LITERAL_typeid:
            case DECIMALINT:
            case HEXADECIMALINT:
            case CharLiteral:
            case WCharLiteral:
            case WStringLiteral:
            case FLOATONE:
            case FLOATTWO:
            case NOT:
            case LITERAL_new:
            case LITERAL_delete: {
              expression();
              break;
            }
            case RPAREN: {
              break;
            }
            default: {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
        }
        match(RPAREN);
        statement();
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::jump_statement() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_goto: {
          match(LITERAL_goto);
          match(ID);
          match(SEMICOLON);
          if (inputState->guessing == 0) {
#line 1791 "CPP_parser.g"
            end_of_stmt();
#line 10065 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_continue: {
          match(LITERAL_continue);
          match(SEMICOLON);
          if (inputState->guessing == 0) {
#line 1792 "CPP_parser.g"
            end_of_stmt();
#line 10076 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_break: {
          match(LITERAL_break);
          match(SEMICOLON);
          if (inputState->guessing == 0) {
#line 1793 "CPP_parser.g"
            end_of_stmt();
#line 10087 "CPPParser.cpp"
          }
          break;
        }
        case LITERAL_return: {
          match(LITERAL_return);
          if (inputState->guessing == 0) {
#line 1795 "CPP_parser.g"
            in_return = true;
#line 10097 "CPPParser.cpp"
          }
          {
            bool synPredMatched428 = false;
            if (((LA(1) == LPAREN) && (LA(2) == ID))) {
              int _m428 = mark();
              synPredMatched428 = true;
              inputState->guessing++;
              try {
                {
                  match(LPAREN);
                  if (!((qualifiedItemIsOneOf(qiType)))) {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        SemanticException("(qualifiedItemIsOneOf(qiType) )");
                  }
                  match(ID);
                  match(RPAREN);
                }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched428 = false;
              }
              rewind(_m428);
              inputState->guessing--;
            }
            if (synPredMatched428) {
              match(LPAREN);
              match(ID);
              match(RPAREN);
              {
                switch (LA(1)) {
                  case ID:
                  case StringLiteral:
                  case LPAREN:
                  case LITERAL_typename:
                  case LITERAL_char:
                  case LITERAL_wchar_t:
                  case LITERAL_bool:
                  case LITERAL_short:
                  case LITERAL_int:
                  case 50:
                  case 51:
                  case 52:
                  case 53:
                  case 54:
                  case 55:
                  case 56:
                  case 57:
                  case 58:
                  case 59:
                  case 60:
                  case 61:
                  case 62:
                  case 63:
                  case 64:
                  case 65:
                  case 66:
                  case 67:
                  case LITERAL_long:
                  case LITERAL_signed:
                  case LITERAL_unsigned:
                  case LITERAL_float:
                  case LITERAL_double:
                  case LITERAL_void:
                  case LITERAL__declspec:
                  case LITERAL___declspec:
                  case OPERATOR:
                  case LITERAL_this:
                  case LITERAL_true:
                  case LITERAL_false:
                  case OCTALINT:
                  case TILDE:
                  case STAR:
                  case AMPERSAND:
                  case PLUS:
                  case MINUS:
                  case PLUSPLUS:
                  case MINUSMINUS:
                  case LITERAL_sizeof:
                  case LITERAL___alignof__:
                  case SCOPE:
                  case LITERAL_dynamic_cast:
                  case LITERAL_static_cast:
                  case LITERAL_reinterpret_cast:
                  case LITERAL_const_cast:
                  case LITERAL_typeid:
                  case DECIMALINT:
                  case HEXADECIMALINT:
                  case CharLiteral:
                  case WCharLiteral:
                  case WStringLiteral:
                  case FLOATONE:
                  case FLOATTWO:
                  case NOT:
                  case LITERAL_new:
                  case LITERAL_delete: {
                    expression();
                    break;
                  }
                  case SEMICOLON: {
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
            } else if ((_tokenSet_72.member(LA(1))) &&
                       (_tokenSet_112.member(LA(2)))) {
              expression();
            } else if ((LA(1) == SEMICOLON)) {
            } else {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
          match(SEMICOLON);
          if (inputState->guessing == 0) {
#line 1802 "CPP_parser.g"
            in_return = false, end_of_stmt();
#line 10220 "CPPParser.cpp"
          }
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::try_block() {
  try {  // for error handling
    match(LITERAL_try);
    compound_statement();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == LITERAL_catch)) {
          handler();
        } else {
          goto _loop432;
        }
      }
    _loop432:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::throw_statement() {
  try {  // for error handling
    match(LITERAL_throw);
    {
      switch (LA(1)) {
        case ID:
        case StringLiteral:
        case LPAREN:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case OCTALINT:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case PLUS:
        case MINUS:
        case PLUSPLUS:
        case MINUSMINUS:
        case LITERAL_sizeof:
        case LITERAL___alignof__:
        case SCOPE:
        case LITERAL_dynamic_cast:
        case LITERAL_static_cast:
        case LITERAL_reinterpret_cast:
        case LITERAL_const_cast:
        case LITERAL_typeid:
        case DECIMALINT:
        case HEXADECIMALINT:
        case CharLiteral:
        case WCharLiteral:
        case WStringLiteral:
        case FLOATONE:
        case FLOATTWO:
        case NOT:
        case LITERAL_new:
        case LITERAL_delete: {
          assignment_expression();
          break;
        }
        case SEMICOLON: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(SEMICOLON);
    if (inputState->guessing == 0) {
#line 1833 "CPP_parser.g"
      end_of_stmt();
#line 10358 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::simple_declaration() {
  try {  // for error handling
    declaration_specifiers();
    {
      switch (LA(1)) {
        case ID:
        case LITERAL__stdcall:
        case LITERAL___stdcall:
        case LPAREN:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case SCOPE:
        case LITERAL__cdecl:
        case LITERAL___cdecl:
        case LITERAL__near:
        case LITERAL___near:
        case LITERAL__far:
        case LITERAL___far:
        case LITERAL___interrupt:
        case LITERAL_pascal:
        case LITERAL__pascal:
        case LITERAL___pascal: {
          init_declarator_list();
          break;
        }
        case SEMICOLON: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(SEMICOLON);
    if (inputState->guessing == 0) {
#line 1725 "CPP_parser.g"
      end_of_stmt();
#line 10417 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::asm_definition() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_asm: {
          match(LITERAL_asm);
          break;
        }
        case LITERAL__asm: {
          match(LITERAL__asm);
          break;
        }
        case LITERAL___asm: {
          match(LITERAL___asm);
          break;
        }
        case LITERAL___asm__: {
          match(LITERAL___asm__);
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(LPAREN);
    match(StringLiteral);
    match(RPAREN);
    match(SEMICOLON);
    if (inputState->guessing == 0) {
#line 1848 "CPP_parser.g"
      end_of_stmt();
#line 10468 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_40);
    } else {
      throw;
    }
  }
}

void CPPParser::handler() {
  try {  // for error handling
    match(LITERAL_catch);
    if (inputState->guessing == 0) {
#line 1814 "CPP_parser.g"
      exceptionBeginHandler();
#line 10488 "CPPParser.cpp"
    }
    if (inputState->guessing == 0) {
#line 1815 "CPP_parser.g"
      declaratorParameterList(1);
#line 10493 "CPPParser.cpp"
    }
    match(LPAREN);
    exception_declaration();
    match(RPAREN);
    if (inputState->guessing == 0) {
#line 1817 "CPP_parser.g"
      declaratorEndParameterList(1);
#line 10501 "CPPParser.cpp"
    }
    compound_statement();
    if (inputState->guessing == 0) {
#line 1819 "CPP_parser.g"
      exceptionEndHandler();
#line 10507 "CPPParser.cpp"
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_114);
    } else {
      throw;
    }
  }
}

void CPPParser::exception_declaration() {
  try {  // for error handling
    parameter_declaration_list();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_71);
    } else {
      throw;
    }
  }
}

void CPPParser::assignment_expression() {
  try {  // for error handling
    conditional_expression();
    {
      switch (LA(1)) {
        case ASSIGNEQUAL:
        case TIMESEQUAL:
        case DIVIDEEQUAL:
        case MINUSEQUAL:
        case PLUSEQUAL:
        case MODEQUAL:
        case SHIFTLEFTEQUAL:
        case SHIFTRIGHTEQUAL:
        case BITWISEANDEQUAL:
        case BITWISEXOREQUAL:
        case BITWISEOREQUAL: {
          {
            switch (LA(1)) {
              case ASSIGNEQUAL: {
                match(ASSIGNEQUAL);
                break;
              }
              case TIMESEQUAL: {
                match(TIMESEQUAL);
                break;
              }
              case DIVIDEEQUAL: {
                match(DIVIDEEQUAL);
                break;
              }
              case MINUSEQUAL: {
                match(MINUSEQUAL);
                break;
              }
              case PLUSEQUAL: {
                match(PLUSEQUAL);
                break;
              }
              case MODEQUAL: {
                match(MODEQUAL);
                break;
              }
              case SHIFTLEFTEQUAL: {
                match(SHIFTLEFTEQUAL);
                break;
              }
              case SHIFTRIGHTEQUAL: {
                match(SHIFTRIGHTEQUAL);
                break;
              }
              case BITWISEANDEQUAL: {
                match(BITWISEANDEQUAL);
                break;
              }
              case BITWISEXOREQUAL: {
                match(BITWISEXOREQUAL);
                break;
              }
              case BITWISEOREQUAL: {
                match(BITWISEOREQUAL);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          remainder_expression();
          break;
        }
        case GREATERTHAN:
        case SEMICOLON:
        case RCURLY:
        case COLON:
        case RPAREN:
        case COMMA:
        case RSQUARE:
        case ELLIPSIS: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_74);
    } else {
      throw;
    }
  }
}

void CPPParser::conditional_expression() {
  try {  // for error handling
    logical_or_expression();
    {
      switch (LA(1)) {
        case QUESTIONMARK: {
          match(QUESTIONMARK);
          expression();
          match(COLON);
          conditional_expression();
          break;
        }
        case GREATERTHAN:
        case SEMICOLON:
        case RCURLY:
        case ASSIGNEQUAL:
        case COLON:
        case RPAREN:
        case COMMA:
        case RSQUARE:
        case ELLIPSIS:
        case TIMESEQUAL:
        case DIVIDEEQUAL:
        case MINUSEQUAL:
        case PLUSEQUAL:
        case MODEQUAL:
        case SHIFTLEFTEQUAL:
        case SHIFTRIGHTEQUAL:
        case BITWISEANDEQUAL:
        case BITWISEXOREQUAL:
        case BITWISEOREQUAL: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_115);
    } else {
      throw;
    }
  }
}

void CPPParser::logical_or_expression() {
  try {  // for error handling
    logical_and_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == OR)) {
          match(OR);
          logical_and_expression();
        } else {
          goto _loop458;
        }
      }
    _loop458:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_116);
    } else {
      throw;
    }
  }
}

void CPPParser::logical_and_expression() {
  try {  // for error handling
    inclusive_or_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == AND)) {
          match(AND);
          inclusive_or_expression();
        } else {
          goto _loop461;
        }
      }
    _loop461:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_117);
    } else {
      throw;
    }
  }
}

void CPPParser::inclusive_or_expression() {
  try {  // for error handling
    exclusive_or_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == BITWISEOR)) {
          match(BITWISEOR);
          exclusive_or_expression();
        } else {
          goto _loop464;
        }
      }
    _loop464:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_118);
    } else {
      throw;
    }
  }
}

void CPPParser::exclusive_or_expression() {
  try {  // for error handling
    and_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == BITWISEXOR)) {
          match(BITWISEXOR);
          and_expression();
        } else {
          goto _loop467;
        }
      }
    _loop467:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_119);
    } else {
      throw;
    }
  }
}

void CPPParser::and_expression() {
  try {  // for error handling
    equality_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == AMPERSAND)) {
          match(AMPERSAND);
          equality_expression();
        } else {
          goto _loop470;
        }
      }
    _loop470:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_120);
    } else {
      throw;
    }
  }
}

void CPPParser::equality_expression() {
  try {  // for error handling
    relational_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == NOTEQUAL || LA(1) == EQUAL)) {
          {
            switch (LA(1)) {
              case NOTEQUAL: {
                match(NOTEQUAL);
                break;
              }
              case EQUAL: {
                match(EQUAL);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          relational_expression();
        } else {
          goto _loop474;
        }
      }
    _loop474:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_121);
    } else {
      throw;
    }
  }
}

void CPPParser::relational_expression() {
  try {  // for error handling
    shift_expression();
    {  // ( ... )*
      for (;;) {
        if ((_tokenSet_122.member(LA(1))) && (_tokenSet_72.member(LA(2)))) {
          {
            switch (LA(1)) {
              case LESSTHAN: {
                match(LESSTHAN);
                break;
              }
              case GREATERTHAN: {
                match(GREATERTHAN);
                break;
              }
              case LESSTHANOREQUALTO: {
                match(LESSTHANOREQUALTO);
                break;
              }
              case GREATERTHANOREQUALTO: {
                match(GREATERTHANOREQUALTO);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          shift_expression();
        } else {
          goto _loop478;
        }
      }
    _loop478:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_123);
    } else {
      throw;
    }
  }
}

void CPPParser::additive_expression() {
  try {  // for error handling
    multiplicative_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == PLUS || LA(1) == MINUS)) {
          {
            switch (LA(1)) {
              case PLUS: {
                match(PLUS);
                break;
              }
              case MINUS: {
                match(MINUS);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          multiplicative_expression();
        } else {
          goto _loop486;
        }
      }
    _loop486:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_124);
    } else {
      throw;
    }
  }
}

void CPPParser::multiplicative_expression() {
  try {  // for error handling
    pm_expression();
    {  // ( ... )*
      for (;;) {
        if ((_tokenSet_125.member(LA(1)))) {
          {
            switch (LA(1)) {
              case STAR: {
                match(STAR);
                break;
              }
              case DIVIDE: {
                match(DIVIDE);
                break;
              }
              case MOD: {
                match(MOD);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          pm_expression();
        } else {
          goto _loop490;
        }
      }
    _loop490:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_126);
    } else {
      throw;
    }
  }
}

void CPPParser::pm_expression() {
  try {  // for error handling
    cast_expression();
    {  // ( ... )*
      for (;;) {
        if ((LA(1) == DOTMBR || LA(1) == POINTERTOMBR)) {
          {
            switch (LA(1)) {
              case DOTMBR: {
                match(DOTMBR);
                break;
              }
              case POINTERTOMBR: {
                match(POINTERTOMBR);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          cast_expression();
        } else {
          goto _loop494;
        }
      }
    _loop494:;
    }  // ( ... )*
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_127);
    } else {
      throw;
    }
  }
}

void CPPParser::cast_expression() {
#line 2021 "CPP_parser.g"
  TypeQualifier tq;
  TypeSpecifier ts;
#line 11084 "CPPParser.cpp"

  try {  // for error handling
    bool synPredMatched501 = false;
    if (((LA(1) == LPAREN) && (_tokenSet_128.member(LA(2))))) {
      int _m501 = mark();
      synPredMatched501 = true;
      inputState->guessing++;
      try {
        {
          match(LPAREN);
          {  // ( ... )*
            for (;;) {
              if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) {
                type_qualifier();
              } else {
                goto _loop498;
              }
            }
          _loop498:;
          }  // ( ... )*
          simple_type_specifier();
          {  // ( ... )*
            for (;;) {
              if ((_tokenSet_25.member(LA(1)))) {
                ptr_operator();
              } else {
                goto _loop500;
              }
            }
          _loop500:;
          }  // ( ... )*
          match(RPAREN);
          unary_expression();
        }
      } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
        synPredMatched501 = false;
      }
      rewind(_m501);
      inputState->guessing--;
    }
    if (synPredMatched501) {
      match(LPAREN);
      {  // ( ... )*
        for (;;) {
          if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) {
            tq = type_qualifier();
          } else {
            goto _loop503;
          }
        }
      _loop503:;
      }  // ( ... )*
      ts = simple_type_specifier();
      {  // ( ... )*
        for (;;) {
          if ((_tokenSet_25.member(LA(1)))) {
            ptr_operator();
          } else {
            goto _loop505;
          }
        }
      _loop505:;
      }  // ( ... )*
      match(RPAREN);
      unary_expression();
    } else {
      bool synPredMatched511 = false;
      if (((LA(1) == LPAREN) && (_tokenSet_128.member(LA(2))))) {
        int _m511 = mark();
        synPredMatched511 = true;
        inputState->guessing++;
        try {
          {
            match(LPAREN);
            {  // ( ... )*
              for (;;) {
                if (((LA(1) >= LITERAL_const &&
                      LA(1) <= LITERAL___volatile__))) {
                  type_qualifier();
                } else {
                  goto _loop508;
                }
              }
            _loop508:;
            }  // ( ... )*
            simple_type_specifier();
            {  // ( ... )*
              for (;;) {
                if ((_tokenSet_25.member(LA(1)))) {
                  ptr_operator();
                } else {
                  goto _loop510;
                }
              }
            _loop510:;
            }  // ( ... )*
            match(RPAREN);
          }
        } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
          synPredMatched511 = false;
        }
        rewind(_m511);
        inputState->guessing--;
      }
      if (synPredMatched511) {
        match(LPAREN);
        {  // ( ... )*
          for (;;) {
            if (((LA(1) >= LITERAL_const && LA(1) <= LITERAL___volatile__))) {
              tq = type_qualifier();
            } else {
              goto _loop513;
            }
          }
        _loop513:;
        }  // ( ... )*
        ts = simple_type_specifier();
        {  // ( ... )*
          for (;;) {
            if ((_tokenSet_25.member(LA(1)))) {
              ptr_operator();
            } else {
              goto _loop515;
            }
          }
        _loop515:;
        }  // ( ... )*
        match(RPAREN);
        cast_expression();
      } else if ((_tokenSet_72.member(LA(1))) && (_tokenSet_73.member(LA(2)))) {
        unary_expression();
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_129);
    } else {
      throw;
    }
  }
}

void CPPParser::unary_expression() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case PLUSPLUS: {
          match(PLUSPLUS);
          unary_expression();
          break;
        }
        case MINUSMINUS: {
          match(MINUSMINUS);
          unary_expression();
          break;
        }
        case LITERAL_sizeof:
        case LITERAL___alignof__: {
          {
            switch (LA(1)) {
              case LITERAL_sizeof: {
                match(LITERAL_sizeof);
                break;
              }
              case LITERAL___alignof__: {
                match(LITERAL___alignof__);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          {
            bool synPredMatched523 = false;
            if (((_tokenSet_72.member(LA(1))) &&
                 (_tokenSet_73.member(LA(2))))) {
              int _m523 = mark();
              synPredMatched523 = true;
              inputState->guessing++;
              try {
                { unary_expression(); }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched523 = false;
              }
              rewind(_m523);
              inputState->guessing--;
            }
            if (synPredMatched523) {
              unary_expression();
            } else if ((LA(1) == LPAREN) && (_tokenSet_12.member(LA(2)))) {
              match(LPAREN);
              type_id();
              match(RPAREN);
            } else {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
          break;
        }
        default:
          bool synPredMatched519 = false;
          if (((_tokenSet_130.member(LA(1))) &&
               (_tokenSet_131.member(LA(2))))) {
            int _m519 = mark();
            synPredMatched519 = true;
            inputState->guessing++;
            try {
              { postfix_expression(); }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched519 = false;
            }
            rewind(_m519);
            inputState->guessing--;
          }
          if (synPredMatched519) {
            postfix_expression();
          } else if ((_tokenSet_132.member(LA(1))) &&
                     (_tokenSet_72.member(LA(2)))) {
            unary_operator();
            cast_expression();
          } else if ((_tokenSet_133.member(LA(1))) &&
                     (_tokenSet_134.member(LA(2)))) {
            {
              switch (LA(1)) {
                case SCOPE: {
                  match(SCOPE);
                  break;
                }
                case LITERAL_new:
                case LITERAL_delete: {
                  break;
                }
                default: {
                  throw ANTLR_USE_NAMESPACE(antlr)
                      NoViableAltException(LT(1), getFilename());
                }
              }
            }
            {
              switch (LA(1)) {
                case LITERAL_new: {
                  new_expression();
                  break;
                }
                case LITERAL_delete: {
                  delete_expression();
                  break;
                }
                default: {
                  throw ANTLR_USE_NAMESPACE(antlr)
                      NoViableAltException(LT(1), getFilename());
                }
              }
            }
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_129);
    } else {
      throw;
    }
  }
}

void CPPParser::postfix_expression() {
#line 2063 "CPP_parser.g"

  TypeSpecifier ts;

#line 11404 "CPPParser.cpp"

  try {  // for error handling
    {
      switch (LA(1)) {
        case LITERAL_dynamic_cast:
        case LITERAL_static_cast:
        case LITERAL_reinterpret_cast:
        case LITERAL_const_cast: {
          {
            switch (LA(1)) {
              case LITERAL_dynamic_cast: {
                match(LITERAL_dynamic_cast);
                break;
              }
              case LITERAL_static_cast: {
                match(LITERAL_static_cast);
                break;
              }
              case LITERAL_reinterpret_cast: {
                match(LITERAL_reinterpret_cast);
                break;
              }
              case LITERAL_const_cast: {
                match(LITERAL_const_cast);
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          match(LESSTHAN);
          {
            switch (LA(1)) {
              case LITERAL_const: {
                match(LITERAL_const);
                break;
              }
              case LITERAL___const: {
                match(LITERAL___const);
                break;
              }
              case ID:
              case LITERAL_typename:
              case LITERAL_char:
              case LITERAL_wchar_t:
              case LITERAL_bool:
              case LITERAL_short:
              case LITERAL_int:
              case 50:
              case 51:
              case 52:
              case 53:
              case 54:
              case 55:
              case 56:
              case 57:
              case 58:
              case 59:
              case 60:
              case 61:
              case 62:
              case 63:
              case 64:
              case 65:
              case 66:
              case 67:
              case LITERAL_long:
              case LITERAL_signed:
              case LITERAL_unsigned:
              case LITERAL_float:
              case LITERAL_double:
              case LITERAL_void:
              case LITERAL__declspec:
              case LITERAL___declspec:
              case SCOPE: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          ts = type_specifier();
          {
            switch (LA(1)) {
              case ID:
              case LITERAL__stdcall:
              case LITERAL___stdcall:
              case STAR:
              case AMPERSAND:
              case SCOPE:
              case LITERAL__cdecl:
              case LITERAL___cdecl:
              case LITERAL__near:
              case LITERAL___near:
              case LITERAL__far:
              case LITERAL___far:
              case LITERAL___interrupt:
              case LITERAL_pascal:
              case LITERAL__pascal:
              case LITERAL___pascal: {
                ptr_operator();
                break;
              }
              case GREATERTHAN: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          match(GREATERTHAN);
          match(LPAREN);
          expression();
          match(RPAREN);
          break;
        }
        case LITERAL_typeid: {
          match(LITERAL_typeid);
          match(LPAREN);
          {
            bool synPredMatched544 = false;
            if (((_tokenSet_12.member(LA(1))) &&
                 (_tokenSet_135.member(LA(2))))) {
              int _m544 = mark();
              synPredMatched544 = true;
              inputState->guessing++;
              try {
                { type_id(); }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched544 = false;
              }
              rewind(_m544);
              inputState->guessing--;
            }
            if (synPredMatched544) {
              type_id();
            } else if ((_tokenSet_72.member(LA(1))) &&
                       (_tokenSet_136.member(LA(2)))) {
              expression();
            } else {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
          match(RPAREN);
          break;
        }
        default:
          bool synPredMatched529 = false;
          if ((((_tokenSet_103.member(LA(1))) &&
                (_tokenSet_137.member(LA(2)))) &&
               (!(LA(1) == LPAREN)))) {
            int _m529 = mark();
            synPredMatched529 = true;
            inputState->guessing++;
            try {
              {
                ts = simple_type_specifier();
                match(LPAREN);
                match(RPAREN);
                match(LPAREN);
              }
            } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
              synPredMatched529 = false;
            }
            rewind(_m529);
            inputState->guessing--;
          }
          if (synPredMatched529) {
            ts = simple_type_specifier();
            match(LPAREN);
            match(RPAREN);
            match(LPAREN);
            {
              switch (LA(1)) {
                case ID:
                case StringLiteral:
                case LPAREN:
                case LITERAL_typename:
                case LITERAL_char:
                case LITERAL_wchar_t:
                case LITERAL_bool:
                case LITERAL_short:
                case LITERAL_int:
                case 50:
                case 51:
                case 52:
                case 53:
                case 54:
                case 55:
                case 56:
                case 57:
                case 58:
                case 59:
                case 60:
                case 61:
                case 62:
                case 63:
                case 64:
                case 65:
                case 66:
                case 67:
                case LITERAL_long:
                case LITERAL_signed:
                case LITERAL_unsigned:
                case LITERAL_float:
                case LITERAL_double:
                case LITERAL_void:
                case LITERAL__declspec:
                case LITERAL___declspec:
                case OPERATOR:
                case LITERAL_this:
                case LITERAL_true:
                case LITERAL_false:
                case OCTALINT:
                case TILDE:
                case STAR:
                case AMPERSAND:
                case PLUS:
                case MINUS:
                case PLUSPLUS:
                case MINUSMINUS:
                case LITERAL_sizeof:
                case LITERAL___alignof__:
                case SCOPE:
                case LITERAL_dynamic_cast:
                case LITERAL_static_cast:
                case LITERAL_reinterpret_cast:
                case LITERAL_const_cast:
                case LITERAL_typeid:
                case DECIMALINT:
                case HEXADECIMALINT:
                case CharLiteral:
                case WCharLiteral:
                case WStringLiteral:
                case FLOATONE:
                case FLOATTWO:
                case NOT:
                case LITERAL_new:
                case LITERAL_delete: {
                  expression_list();
                  break;
                }
                case RPAREN: {
                  break;
                }
                default: {
                  throw ANTLR_USE_NAMESPACE(antlr)
                      NoViableAltException(LT(1), getFilename());
                }
              }
            }
            match(RPAREN);
          } else {
            bool synPredMatched532 = false;
            if ((((_tokenSet_103.member(LA(1))) &&
                  (_tokenSet_137.member(LA(2)))) &&
                 (!(LA(1) == LPAREN)))) {
              int _m532 = mark();
              synPredMatched532 = true;
              inputState->guessing++;
              try {
                {
                  ts = simple_type_specifier();
                  match(LPAREN);
                }
              } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
                synPredMatched532 = false;
              }
              rewind(_m532);
              inputState->guessing--;
            }
            if (synPredMatched532) {
              ts = simple_type_specifier();
              match(LPAREN);
              {
                switch (LA(1)) {
                  case ID:
                  case StringLiteral:
                  case LPAREN:
                  case LITERAL_typename:
                  case LITERAL_char:
                  case LITERAL_wchar_t:
                  case LITERAL_bool:
                  case LITERAL_short:
                  case LITERAL_int:
                  case 50:
                  case 51:
                  case 52:
                  case 53:
                  case 54:
                  case 55:
                  case 56:
                  case 57:
                  case 58:
                  case 59:
                  case 60:
                  case 61:
                  case 62:
                  case 63:
                  case 64:
                  case 65:
                  case 66:
                  case 67:
                  case LITERAL_long:
                  case LITERAL_signed:
                  case LITERAL_unsigned:
                  case LITERAL_float:
                  case LITERAL_double:
                  case LITERAL_void:
                  case LITERAL__declspec:
                  case LITERAL___declspec:
                  case OPERATOR:
                  case LITERAL_this:
                  case LITERAL_true:
                  case LITERAL_false:
                  case OCTALINT:
                  case TILDE:
                  case STAR:
                  case AMPERSAND:
                  case PLUS:
                  case MINUS:
                  case PLUSPLUS:
                  case MINUSMINUS:
                  case LITERAL_sizeof:
                  case LITERAL___alignof__:
                  case SCOPE:
                  case LITERAL_dynamic_cast:
                  case LITERAL_static_cast:
                  case LITERAL_reinterpret_cast:
                  case LITERAL_const_cast:
                  case LITERAL_typeid:
                  case DECIMALINT:
                  case HEXADECIMALINT:
                  case CharLiteral:
                  case WCharLiteral:
                  case WStringLiteral:
                  case FLOATONE:
                  case FLOATTWO:
                  case NOT:
                  case LITERAL_new:
                  case LITERAL_delete: {
                    expression_list();
                    break;
                  }
                  case RPAREN: {
                    break;
                  }
                  default: {
                    throw ANTLR_USE_NAMESPACE(antlr)
                        NoViableAltException(LT(1), getFilename());
                  }
                }
              }
              match(RPAREN);
            } else if ((_tokenSet_138.member(LA(1))) &&
                       (_tokenSet_131.member(LA(2)))) {
              primary_expression();
              {  // ( ... )*
                for (;;) {
                  switch (LA(1)) {
                    case LSQUARE: {
                      match(LSQUARE);
                      expression();
                      match(RSQUARE);
                      break;
                    }
                    case LPAREN: {
                      match(LPAREN);
                      {
                        switch (LA(1)) {
                          case ID:
                          case StringLiteral:
                          case LPAREN:
                          case LITERAL_typename:
                          case LITERAL_char:
                          case LITERAL_wchar_t:
                          case LITERAL_bool:
                          case LITERAL_short:
                          case LITERAL_int:
                          case 50:
                          case 51:
                          case 52:
                          case 53:
                          case 54:
                          case 55:
                          case 56:
                          case 57:
                          case 58:
                          case 59:
                          case 60:
                          case 61:
                          case 62:
                          case 63:
                          case 64:
                          case 65:
                          case 66:
                          case 67:
                          case LITERAL_long:
                          case LITERAL_signed:
                          case LITERAL_unsigned:
                          case LITERAL_float:
                          case LITERAL_double:
                          case LITERAL_void:
                          case LITERAL__declspec:
                          case LITERAL___declspec:
                          case OPERATOR:
                          case LITERAL_this:
                          case LITERAL_true:
                          case LITERAL_false:
                          case OCTALINT:
                          case TILDE:
                          case STAR:
                          case AMPERSAND:
                          case PLUS:
                          case MINUS:
                          case PLUSPLUS:
                          case MINUSMINUS:
                          case LITERAL_sizeof:
                          case LITERAL___alignof__:
                          case SCOPE:
                          case LITERAL_dynamic_cast:
                          case LITERAL_static_cast:
                          case LITERAL_reinterpret_cast:
                          case LITERAL_const_cast:
                          case LITERAL_typeid:
                          case DECIMALINT:
                          case HEXADECIMALINT:
                          case CharLiteral:
                          case WCharLiteral:
                          case WStringLiteral:
                          case FLOATONE:
                          case FLOATTWO:
                          case NOT:
                          case LITERAL_new:
                          case LITERAL_delete: {
                            expression_list();
                            break;
                          }
                          case RPAREN: {
                            break;
                          }
                          default: {
                            throw ANTLR_USE_NAMESPACE(antlr)
                                NoViableAltException(LT(1), getFilename());
                          }
                        }
                      }
                      match(RPAREN);
                      break;
                    }
                    case DOT:
                    case POINTERTO: {
                      {
                        switch (LA(1)) {
                          case DOT: {
                            match(DOT);
                            break;
                          }
                          case POINTERTO: {
                            match(POINTERTO);
                            break;
                          }
                          default: {
                            throw ANTLR_USE_NAMESPACE(antlr)
                                NoViableAltException(LT(1), getFilename());
                          }
                        }
                      }
                      {
                        switch (LA(1)) {
                          case LITERAL_template: {
                            match(LITERAL_template);
                            break;
                          }
                          case ID:
                          case OPERATOR:
                          case TILDE:
                          case SCOPE: {
                            break;
                          }
                          default: {
                            throw ANTLR_USE_NAMESPACE(antlr)
                                NoViableAltException(LT(1), getFilename());
                          }
                        }
                      }
                      id_expression();
                      break;
                    }
                    case PLUSPLUS: {
                      match(PLUSPLUS);
                      break;
                    }
                    case MINUSMINUS: {
                      match(MINUSMINUS);
                      break;
                    }
                    default: { goto _loop538; }
                  }
                }
              _loop538:;
              }  // ( ... )*
            } else {
              throw ANTLR_USE_NAMESPACE(antlr)
                  NoViableAltException(LT(1), getFilename());
            }
          }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_129);
    } else {
      throw;
    }
  }
}

void CPPParser::unary_operator() {
  try {  // for error handling
    switch (LA(1)) {
      case AMPERSAND: {
        match(AMPERSAND);
        break;
      }
      case STAR: {
        match(STAR);
        break;
      }
      case PLUS: {
        match(PLUS);
        break;
      }
      case MINUS: {
        match(MINUS);
        break;
      }
      case TILDE: {
        match(TILDE);
        break;
      }
      case NOT: {
        match(NOT);
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_72);
    } else {
      throw;
    }
  }
}

void CPPParser::new_expression() {
  try {  // for error handling
    {
      match(LITERAL_new);
      {
        bool synPredMatched557 = false;
        if (((LA(1) == LPAREN) && (_tokenSet_72.member(LA(2))))) {
          int _m557 = mark();
          synPredMatched557 = true;
          inputState->guessing++;
          try {
            {
              match(LPAREN);
              expression_list();
              match(RPAREN);
            }
          } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& pe) {
            synPredMatched557 = false;
          }
          rewind(_m557);
          inputState->guessing--;
        }
        if (synPredMatched557) {
          match(LPAREN);
          expression_list();
          match(RPAREN);
        } else if ((_tokenSet_139.member(LA(1))) &&
                   (_tokenSet_140.member(LA(2)))) {
        } else {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
      {
        switch (LA(1)) {
          case LITERAL_typedef:
          case LITERAL_enum:
          case ID:
          case LITERAL_inline:
          case LITERAL_friend:
          case LITERAL_extern:
          case LITERAL_struct:
          case LITERAL_union:
          case LITERAL_class:
          case LITERAL__stdcall:
          case LITERAL___stdcall:
          case LITERAL_GFEXCLUDE:
          case LITERAL_GFINCLUDE:
          case LITERAL_GFID:
          case LITERAL_GFUNREAD:
          case LITERAL_GFARRAYSIZE:
          case LITERAL_GFARRAYSIZES:
          case LITERAL_GFARRAYELEMSIZE:
          case LITERAL_auto:
          case LITERAL_register:
          case LITERAL_static:
          case LITERAL_mutable:
          case LITERAL__inline:
          case LITERAL___inline:
          case LITERAL_virtual:
          case LITERAL_explicit:
          case LITERAL_typename:
          case LITERAL_char:
          case LITERAL_wchar_t:
          case LITERAL_bool:
          case LITERAL_short:
          case LITERAL_int:
          case 50:
          case 51:
          case 52:
          case 53:
          case 54:
          case 55:
          case 56:
          case 57:
          case 58:
          case 59:
          case 60:
          case 61:
          case 62:
          case 63:
          case 64:
          case 65:
          case 66:
          case 67:
          case LITERAL_long:
          case LITERAL_signed:
          case LITERAL_unsigned:
          case LITERAL_float:
          case LITERAL_double:
          case LITERAL_void:
          case LITERAL__declspec:
          case LITERAL___declspec:
          case LITERAL_const:
          case LITERAL___const:
          case LITERAL_volatile:
          case LITERAL___volatile__:
          case SCOPE: {
            new_type_id();
            break;
          }
          case LPAREN: {
            match(LPAREN);
            type_id();
            match(RPAREN);
            break;
          }
          default: {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
      }
      {
        switch (LA(1)) {
          case LPAREN: {
            new_initializer();
            break;
          }
          case LESSTHAN:
          case GREATERTHAN:
          case SEMICOLON:
          case RCURLY:
          case ASSIGNEQUAL:
          case COLON:
          case RPAREN:
          case COMMA:
          case RSQUARE:
          case STAR:
          case AMPERSAND:
          case ELLIPSIS:
          case TIMESEQUAL:
          case DIVIDEEQUAL:
          case MINUSEQUAL:
          case PLUSEQUAL:
          case MODEQUAL:
          case SHIFTLEFTEQUAL:
          case SHIFTRIGHTEQUAL:
          case BITWISEANDEQUAL:
          case BITWISEXOREQUAL:
          case BITWISEOREQUAL:
          case QUESTIONMARK:
          case OR:
          case AND:
          case BITWISEOR:
          case BITWISEXOR:
          case NOTEQUAL:
          case EQUAL:
          case LESSTHANOREQUALTO:
          case GREATERTHANOREQUALTO:
          case SHIFTLEFT:
          case SHIFTRIGHT:
          case PLUS:
          case MINUS:
          case DIVIDE:
          case MOD:
          case DOTMBR:
          case POINTERTOMBR: {
            break;
          }
          default: {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_129);
    } else {
      throw;
    }
  }
}

void CPPParser::delete_expression() {
  try {  // for error handling
    match(LITERAL_delete);
    {
      switch (LA(1)) {
        case LSQUARE: {
          match(LSQUARE);
          match(RSQUARE);
          break;
        }
        case ID:
        case StringLiteral:
        case LPAREN:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case OCTALINT:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case PLUS:
        case MINUS:
        case PLUSPLUS:
        case MINUSMINUS:
        case LITERAL_sizeof:
        case LITERAL___alignof__:
        case SCOPE:
        case LITERAL_dynamic_cast:
        case LITERAL_static_cast:
        case LITERAL_reinterpret_cast:
        case LITERAL_const_cast:
        case LITERAL_typeid:
        case DECIMALINT:
        case HEXADECIMALINT:
        case CharLiteral:
        case WCharLiteral:
        case WStringLiteral:
        case FLOATONE:
        case FLOATTWO:
        case NOT:
        case LITERAL_new:
        case LITERAL_delete: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    cast_expression();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_129);
    } else {
      throw;
    }
  }
}

void CPPParser::primary_expression() {
  try {  // for error handling
    switch (LA(1)) {
      case ID:
      case OPERATOR:
      case TILDE:
      case SCOPE: {
        id_expression();
        break;
      }
      case StringLiteral:
      case LITERAL_true:
      case LITERAL_false:
      case OCTALINT:
      case DECIMALINT:
      case HEXADECIMALINT:
      case CharLiteral:
      case WCharLiteral:
      case WStringLiteral:
      case FLOATONE:
      case FLOATTWO: {
        constant();
        break;
      }
      case LITERAL_this: {
        match(LITERAL_this);
        break;
      }
      case LPAREN: {
        match(LPAREN);
        expression();
        match(RPAREN);
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_141);
    } else {
      throw;
    }
  }
}

void CPPParser::id_expression() {
#line 2105 "CPP_parser.g"
  char* s;
#line 12353 "CPPParser.cpp"

  try {  // for error handling
    s = scope_override();
    {
      switch (LA(1)) {
        case ID: {
          match(ID);
          break;
        }
        case OPERATOR: {
          match(OPERATOR);
          optor();
          break;
        }
        case TILDE: {
          match(TILDE);
          {
            switch (LA(1)) {
              case STAR: {
                match(STAR);
                break;
              }
              case ID: {
                break;
              }
              default: {
                throw ANTLR_USE_NAMESPACE(antlr)
                    NoViableAltException(LT(1), getFilename());
              }
            }
          }
          match(ID);
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_141);
    } else {
      throw;
    }
  }
}

void CPPParser::constant() {
  try {  // for error handling
    switch (LA(1)) {
      case OCTALINT: {
        match(OCTALINT);
        break;
      }
      case DECIMALINT: {
        match(DECIMALINT);
        break;
      }
      case HEXADECIMALINT: {
        match(HEXADECIMALINT);
        break;
      }
      case CharLiteral: {
        match(CharLiteral);
        break;
      }
      case WCharLiteral: {
        match(WCharLiteral);
        break;
      }
      case StringLiteral:
      case WStringLiteral: {
        {  // ( ... )+
          int _cnt551 = 0;
          for (;;) {
            switch (LA(1)) {
              case StringLiteral: {
                match(StringLiteral);
                break;
              }
              case WStringLiteral: {
                match(WStringLiteral);
                break;
              }
              default: {
                if (_cnt551 >= 1) {
                  goto _loop551;
                } else {
                  throw ANTLR_USE_NAMESPACE(antlr)
                      NoViableAltException(LT(1), getFilename());
                }
              }
            }
            _cnt551++;
          }
        _loop551:;
        }  // ( ... )+
        break;
      }
      case FLOATONE: {
        match(FLOATONE);
        break;
      }
      case FLOATTWO: {
        match(FLOATTWO);
        break;
      }
      case LITERAL_true: {
        match(LITERAL_true);
        break;
      }
      case LITERAL_false: {
        match(LITERAL_false);
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_141);
    } else {
      throw;
    }
  }
}

void CPPParser::new_type_id() {
  try {  // for error handling
    declaration_specifiers();
    {
      if ((_tokenSet_142.member(LA(1))) && (_tokenSet_143.member(LA(2)))) {
        new_declarator();
      } else if ((_tokenSet_144.member(LA(1))) &&
                 (_tokenSet_57.member(LA(2)))) {
      } else {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_144);
    } else {
      throw;
    }
  }
}

void CPPParser::new_initializer() {
  try {  // for error handling
    match(LPAREN);
    {
      switch (LA(1)) {
        case ID:
        case StringLiteral:
        case LPAREN:
        case LITERAL_typename:
        case LITERAL_char:
        case LITERAL_wchar_t:
        case LITERAL_bool:
        case LITERAL_short:
        case LITERAL_int:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
        case 64:
        case 65:
        case 66:
        case 67:
        case LITERAL_long:
        case LITERAL_signed:
        case LITERAL_unsigned:
        case LITERAL_float:
        case LITERAL_double:
        case LITERAL_void:
        case LITERAL__declspec:
        case LITERAL___declspec:
        case OPERATOR:
        case LITERAL_this:
        case LITERAL_true:
        case LITERAL_false:
        case OCTALINT:
        case TILDE:
        case STAR:
        case AMPERSAND:
        case PLUS:
        case MINUS:
        case PLUSPLUS:
        case MINUSMINUS:
        case LITERAL_sizeof:
        case LITERAL___alignof__:
        case SCOPE:
        case LITERAL_dynamic_cast:
        case LITERAL_static_cast:
        case LITERAL_reinterpret_cast:
        case LITERAL_const_cast:
        case LITERAL_typeid:
        case DECIMALINT:
        case HEXADECIMALINT:
        case CharLiteral:
        case WCharLiteral:
        case WStringLiteral:
        case FLOATONE:
        case FLOATTWO:
        case NOT:
        case LITERAL_new:
        case LITERAL_delete: {
          expression_list();
          break;
        }
        case RPAREN: {
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
    match(RPAREN);
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_129);
    } else {
      throw;
    }
  }
}

void CPPParser::new_declarator() {
  try {  // for error handling
    switch (LA(1)) {
      case ID:
      case LITERAL__stdcall:
      case LITERAL___stdcall:
      case STAR:
      case AMPERSAND:
      case SCOPE:
      case LITERAL__cdecl:
      case LITERAL___cdecl:
      case LITERAL__near:
      case LITERAL___near:
      case LITERAL__far:
      case LITERAL___far:
      case LITERAL___interrupt:
      case LITERAL_pascal:
      case LITERAL__pascal:
      case LITERAL___pascal: {
        ptr_operator();
        {
          if ((_tokenSet_142.member(LA(1))) && (_tokenSet_143.member(LA(2)))) {
            new_declarator();
          } else if ((_tokenSet_144.member(LA(1))) &&
                     (_tokenSet_57.member(LA(2)))) {
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }
        break;
      }
      case LSQUARE: {
        direct_new_declarator();
        break;
      }
      default: {
        throw ANTLR_USE_NAMESPACE(antlr)
            NoViableAltException(LT(1), getFilename());
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_144);
    } else {
      throw;
    }
  }
}

void CPPParser::direct_new_declarator() {
  try {  // for error handling
    {    // ( ... )+
      int _cnt570 = 0;
      for (;;) {
        if ((LA(1) == LSQUARE)) {
          match(LSQUARE);
          expression();
          match(RSQUARE);
        } else {
          if (_cnt570 >= 1) {
            goto _loop570;
          } else {
            throw ANTLR_USE_NAMESPACE(antlr)
                NoViableAltException(LT(1), getFilename());
          }
        }

        _cnt570++;
      }
    _loop570:;
    }  // ( ... )+
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_144);
    } else {
      throw;
    }
  }
}

void CPPParser::ptr_to_member() {
#line 2211 "CPP_parser.g"
  char* s;
#line 12715 "CPPParser.cpp"

  try {  // for error handling
    s = scope_override();
    match(STAR);
    if (inputState->guessing == 0) {
#line 2214 "CPP_parser.g"
      is_pointer = true;
#line 12723 "CPPParser.cpp"
    }
    cv_qualifier_seq();
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_24);
    } else {
      throw;
    }
  }
}

void CPPParser::optor_simple_tokclass() {
  try {  // for error handling
    {
      switch (LA(1)) {
        case PLUS: {
          match(PLUS);
          break;
        }
        case MINUS: {
          match(MINUS);
          break;
        }
        case STAR: {
          match(STAR);
          break;
        }
        case DIVIDE: {
          match(DIVIDE);
          break;
        }
        case MOD: {
          match(MOD);
          break;
        }
        case BITWISEXOR: {
          match(BITWISEXOR);
          break;
        }
        case AMPERSAND: {
          match(AMPERSAND);
          break;
        }
        case BITWISEOR: {
          match(BITWISEOR);
          break;
        }
        case TILDE: {
          match(TILDE);
          break;
        }
        case NOT: {
          match(NOT);
          break;
        }
        case SHIFTLEFT: {
          match(SHIFTLEFT);
          break;
        }
        case SHIFTRIGHT: {
          match(SHIFTRIGHT);
          break;
        }
        case ASSIGNEQUAL: {
          match(ASSIGNEQUAL);
          break;
        }
        case TIMESEQUAL: {
          match(TIMESEQUAL);
          break;
        }
        case DIVIDEEQUAL: {
          match(DIVIDEEQUAL);
          break;
        }
        case MODEQUAL: {
          match(MODEQUAL);
          break;
        }
        case PLUSEQUAL: {
          match(PLUSEQUAL);
          break;
        }
        case MINUSEQUAL: {
          match(MINUSEQUAL);
          break;
        }
        case SHIFTLEFTEQUAL: {
          match(SHIFTLEFTEQUAL);
          break;
        }
        case SHIFTRIGHTEQUAL: {
          match(SHIFTRIGHTEQUAL);
          break;
        }
        case BITWISEANDEQUAL: {
          match(BITWISEANDEQUAL);
          break;
        }
        case BITWISEXOREQUAL: {
          match(BITWISEXOREQUAL);
          break;
        }
        case BITWISEOREQUAL: {
          match(BITWISEOREQUAL);
          break;
        }
        case EQUAL: {
          match(EQUAL);
          break;
        }
        case NOTEQUAL: {
          match(NOTEQUAL);
          break;
        }
        case LESSTHAN: {
          match(LESSTHAN);
          break;
        }
        case GREATERTHAN: {
          match(GREATERTHAN);
          break;
        }
        case LESSTHANOREQUALTO: {
          match(LESSTHANOREQUALTO);
          break;
        }
        case GREATERTHANOREQUALTO: {
          match(GREATERTHANOREQUALTO);
          break;
        }
        case OR: {
          match(OR);
          break;
        }
        case AND: {
          match(AND);
          break;
        }
        case PLUSPLUS: {
          match(PLUSPLUS);
          break;
        }
        case MINUSMINUS: {
          match(MINUSMINUS);
          break;
        }
        case COMMA: {
          match(COMMA);
          break;
        }
        case POINTERTO: {
          match(POINTERTO);
          break;
        }
        case POINTERTOMBR: {
          match(POINTERTOMBR);
          break;
        }
        default: {
          throw ANTLR_USE_NAMESPACE(antlr)
              NoViableAltException(LT(1), getFilename());
        }
      }
    }
  } catch (ANTLR_USE_NAMESPACE(antlr) RecognitionException& ex) {
    if (inputState->guessing == 0) {
      reportError(ex);
      recover(ex, _tokenSet_64);
    } else {
      throw;
    }
  }
}

void CPPParser::initializeASTFactory(ANTLR_USE_NAMESPACE(antlr) ASTFactory&) {}
const char* CPPParser::tokenNames[] = {"<0>",
                                       "EOF",
                                       "<2>",
                                       "NULL_TREE_LOOKAHEAD",
                                       "\"template\"",
                                       "LESSTHAN",
                                       "GREATERTHAN",
                                       "\"typedef\"",
                                       "SEMICOLON",
                                       "\"enum\"",
                                       "ID",
                                       "LCURLY",
                                       "\"inline\"",
                                       "\"friend\"",
                                       "\"namespace\"",
                                       "\"antlrTrace_on\"",
                                       "\"antlrTrace_off\"",
                                       "RCURLY",
                                       "ASSIGNEQUAL",
                                       "COLON",
                                       "\"extern\"",
                                       "StringLiteral",
                                       "\"struct\"",
                                       "\"union\"",
                                       "\"class\"",
                                       "\"_stdcall\"",
                                       "\"__stdcall\"",
                                       "\"GFEXCLUDE\"",
                                       "\"GFINCLUDE\"",
                                       "\"GFID\"",
                                       "\"GFUNREAD\"",
                                       "\"GFARRAYSIZE\"",
                                       "LPAREN",
                                       "RPAREN",
                                       "\"GFARRAYSIZES\"",
                                       "\"GFARRAYELEMSIZE\"",
                                       "\"auto\"",
                                       "\"register\"",
                                       "\"static\"",
                                       "\"mutable\"",
                                       "\"_inline\"",
                                       "\"__inline\"",
                                       "\"virtual\"",
                                       "\"explicit\"",
                                       "\"typename\"",
                                       "\"char\"",
                                       "\"wchar_t\"",
                                       "\"bool\"",
                                       "\"short\"",
                                       "\"int\"",
                                       "\"_int8\"",
                                       "\"__int8\"",
                                       "\"int8_t\"",
                                       "\"_int16\"",
                                       "\"__int16\"",
                                       "\"int16_t\"",
                                       "\"_int32\"",
                                       "\"__int32\"",
                                       "\"int32_t\"",
                                       "\"_int64\"",
                                       "\"__int64\"",
                                       "\"int64_t\"",
                                       "\"uint8_t\"",
                                       "\"uint16_t\"",
                                       "\"uint32_t\"",
                                       "\"uint64_t\"",
                                       "\"_w64\"",
                                       "\"__w64\"",
                                       "\"long\"",
                                       "\"signed\"",
                                       "\"unsigned\"",
                                       "\"float\"",
                                       "\"double\"",
                                       "\"void\"",
                                       "\"_declspec\"",
                                       "\"__declspec\"",
                                       "\"const\"",
                                       "\"__const\"",
                                       "\"volatile\"",
                                       "\"__volatile__\"",
                                       "\"GFIGNORE\"",
                                       "COMMA",
                                       "\"public\"",
                                       "\"protected\"",
                                       "\"private\"",
                                       "\"operator\"",
                                       "\"this\"",
                                       "\"true\"",
                                       "\"false\"",
                                       "OCTALINT",
                                       "LSQUARE",
                                       "RSQUARE",
                                       "TILDE",
                                       "STAR",
                                       "AMPERSAND",
                                       "ELLIPSIS",
                                       "\"throw\"",
                                       "\"using\"",
                                       "\"case\"",
                                       "\"default\"",
                                       "\"if\"",
                                       "\"else\"",
                                       "\"switch\"",
                                       "\"while\"",
                                       "\"do\"",
                                       "\"for\"",
                                       "\"goto\"",
                                       "\"continue\"",
                                       "\"break\"",
                                       "\"return\"",
                                       "\"try\"",
                                       "\"catch\"",
                                       "\"asm\"",
                                       "\"_asm\"",
                                       "\"__asm\"",
                                       "\"__asm__\"",
                                       "TIMESEQUAL",
                                       "DIVIDEEQUAL",
                                       "MINUSEQUAL",
                                       "PLUSEQUAL",
                                       "MODEQUAL",
                                       "SHIFTLEFTEQUAL",
                                       "SHIFTRIGHTEQUAL",
                                       "BITWISEANDEQUAL",
                                       "BITWISEXOREQUAL",
                                       "BITWISEOREQUAL",
                                       "QUESTIONMARK",
                                       "OR",
                                       "AND",
                                       "BITWISEOR",
                                       "BITWISEXOR",
                                       "NOTEQUAL",
                                       "EQUAL",
                                       "LESSTHANOREQUALTO",
                                       "GREATERTHANOREQUALTO",
                                       "SHIFTLEFT",
                                       "SHIFTRIGHT",
                                       "PLUS",
                                       "MINUS",
                                       "DIVIDE",
                                       "MOD",
                                       "DOTMBR",
                                       "POINTERTOMBR",
                                       "PLUSPLUS",
                                       "MINUSMINUS",
                                       "\"sizeof\"",
                                       "\"__alignof__\"",
                                       "SCOPE",
                                       "DOT",
                                       "POINTERTO",
                                       "\"dynamic_cast\"",
                                       "\"static_cast\"",
                                       "\"reinterpret_cast\"",
                                       "\"const_cast\"",
                                       "\"typeid\"",
                                       "DECIMALINT",
                                       "HEXADECIMALINT",
                                       "CharLiteral",
                                       "WCharLiteral",
                                       "WStringLiteral",
                                       "FLOATONE",
                                       "FLOATTWO",
                                       "NOT",
                                       "\"new\"",
                                       "\"_cdecl\"",
                                       "\"__cdecl\"",
                                       "\"_near\"",
                                       "\"__near\"",
                                       "\"_far\"",
                                       "\"__far\"",
                                       "\"__interrupt\"",
                                       "\"pascal\"",
                                       "\"_pascal\"",
                                       "\"__pascal\"",
                                       "\"delete\"",
                                       "Whitespace",
                                       "Comment",
                                       "CPPComment",
                                       "a preprocessor directive",
                                       "LineDirective",
                                       "Space",
                                       "Pragma",
                                       "Error",
                                       "EndOfLine",
                                       "Escape",
                                       "Digit",
                                       "Decimal",
                                       "LongSuffix",
                                       "UnsignedSuffix",
                                       "FloatSuffix",
                                       "Exponent",
                                       "Vocabulary",
                                       "Number",
                                       0};

const unsigned long CPPParser::_tokenSet_0_data_[] = {
    4291950480UL, 4294967293UL, 1910571007UL, 2UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// "template" "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace"
// "antlrTrace_on" "antlrTrace_off" "extern" "struct" "union" "class" "_stdcall"
// "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND
// "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_0(
    _tokenSet_0_data_, 12);
const unsigned long CPPParser::_tokenSet_1_data_[] = {2UL, 0UL, 0UL, 0UL,
                                                      0UL, 0UL, 0UL, 0UL};
// EOF
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_1(
    _tokenSet_1_data_, 8);
const unsigned long CPPParser::_tokenSet_2_data_[] = {
    4291835520UL, 4294967292UL, 65535UL, 2UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,     0UL, 0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "using" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_2(
    _tokenSet_2_data_, 12);
const unsigned long CPPParser::_tokenSet_3_data_[] = {
    4293949344UL, 4294967293UL, 1910571007UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace"
// "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall"
// "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES"
// "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline"
// "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int"
// "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32"
// "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t"
// "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double"
// "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__"
// "operator" "this" "true" "false" TILDE STAR AMPERSAND SCOPE "_cdecl"
// "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal"
// "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_3(
    _tokenSet_3_data_, 12);
const unsigned long CPPParser::_tokenSet_4_data_[] = {4096UL, 3840UL, 0UL, 0UL,
                                                      0UL,    0UL,    0UL, 0UL};
// "inline" "_inline" "__inline" "virtual" "explicit"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_4(
    _tokenSet_4_data_, 8);
const unsigned long CPPParser::_tokenSet_5_data_[] = {
    3072UL, 0UL, 31457280UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID LCURLY "operator" "this" "true" "false" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_5(
    _tokenSet_5_data_, 12);
const unsigned long CPPParser::_tokenSet_6_data_[] = {
    5136UL, 1792UL, 268435456UL, 0UL, 524288UL, 0UL,
    0UL,    0UL,    0UL,         0UL, 0UL,      0UL};
// "template" ID "inline" "_inline" "__inline" "virtual" TILDE SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_6(
    _tokenSet_6_data_, 12);
const unsigned long CPPParser::_tokenSet_7_data_[] = {
    5152UL, 1792UL, 268435456UL, 0UL, 524288UL, 0UL,
    0UL,    0UL,    0UL,         0UL, 0UL,      0UL};
// LESSTHAN ID "inline" "_inline" "__inline" "virtual" TILDE SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_7(
    _tokenSet_7_data_, 12);
const unsigned long CPPParser::_tokenSet_8_data_[] = {
    5120UL, 2816UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID "inline" "_inline" "__inline" "explicit" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_8(
    _tokenSet_8_data_, 12);
const unsigned long CPPParser::_tokenSet_9_data_[] = {
    5152UL, 2817UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// LESSTHAN ID "inline" LPAREN "_inline" "__inline" "explicit" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_9(
    _tokenSet_9_data_, 12);
const unsigned long CPPParser::_tokenSet_10_data_[] = {
    5120UL, 0UL, 2097152UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID "inline" "operator" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_10(
    _tokenSet_10_data_, 12);
const unsigned long CPPParser::_tokenSet_11_data_[] = {
    4291835552UL, 4294967292UL, 2162687UL, 0UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,       0UL, 0UL,      0UL};
// LESSTHAN "typedef" "enum" ID "inline" "friend" "extern" "struct" "union"
// "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static"
// "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char"
// "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16"
// "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t"
// "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed"
// "unsigned" "float" "double" "void" "_declspec" "__declspec" "const"
// "__const" "volatile" "__volatile__" "operator" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_11(
    _tokenSet_11_data_, 12);
const unsigned long CPPParser::_tokenSet_12_data_[] = {
    4291835520UL, 4294967292UL, 65535UL, 0UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,     0UL, 0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_12(
    _tokenSet_12_data_, 12);
const unsigned long CPPParser::_tokenSet_13_data_[] = {
    4291835552UL, 4294967293UL, 1642135551UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN "typedef" "enum" ID "inline" "friend" "extern" "struct" "union"
// "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register"
// "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename"
// "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16"
// "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "operator" "this" "true"
// "false" STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far"
// "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_13(
    _tokenSet_13_data_, 12);
const unsigned long CPPParser::_tokenSet_14_data_[] = {
    4291835520UL, 4294967293UL, 1642135551UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "operator" "this" "true" "false" STAR AMPERSAND SCOPE
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_14(
    _tokenSet_14_data_, 12);
const unsigned long CPPParser::_tokenSet_15_data_[] = {
    4292097760UL, 4294967293UL, 1977810943UL, 3220176896UL, 2744319UL, 32764UL,
    0UL,          0UL,          0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL
// "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE"
// "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES"
// "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" COMMA "operator"
// "this" "true" "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL
// MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL
// EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS
// MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT
// "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt"
// "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_15(
    _tokenSet_15_data_, 12);
const unsigned long CPPParser::_tokenSet_16_data_[] = {
    29372416UL, 3840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// "inline" "friend" "struct" "union" "class" "_inline" "__inline" "virtual"
// "explicit"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_16(
    _tokenSet_16_data_, 8);
const unsigned long CPPParser::_tokenSet_17_data_[] = {
    29367296UL, 3840UL, 31525888UL, 0UL, 524288UL, 0UL,
    0UL,        0UL,    0UL,        0UL, 0UL,      0UL};
// ID LCURLY "inline" "struct" "union" "class" "_inline" "__inline" "virtual"
// "explicit" "_declspec" "__declspec" "GFIGNORE" "operator" "this" "true"
// "false" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_17(
    _tokenSet_17_data_, 12);
const unsigned long CPPParser::_tokenSet_18_data_[] = {
    4291835808UL, 4294967293UL, 1910571007UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" "extern" "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "operator" "this" "true"
// "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near"
// "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_18(
    _tokenSet_18_data_, 12);
const unsigned long CPPParser::_tokenSet_19_data_[] = {
    4292081554UL, 4294967293UL, 1910571007UL, 2UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// EOF "template" "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace"
// "antlrTrace_on" "antlrTrace_off" RCURLY "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND
// "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_19(
    _tokenSet_19_data_, 12);
const unsigned long CPPParser::_tokenSet_20_data_[] = {
    4291934096UL, 4294967293UL, 1912406015UL, 2UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// "template" "typedef" SEMICOLON "enum" ID "inline" "friend" "antlrTrace_on"
// "antlrTrace_off" "extern" "struct" "union" "class" "_stdcall" "__stdcall"
// "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES"
// "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline"
// "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int"
// "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32"
// "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t"
// "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double"
// "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__"
// "public" "protected" "private" "operator" "this" "true" "false" TILDE
// STAR AMPERSAND "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far"
// "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_20(
    _tokenSet_20_data_, 12);
const unsigned long CPPParser::_tokenSet_21_data_[] = {
    100664576UL, 1UL, 1910505472UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// SEMICOLON ID "_stdcall" "__stdcall" LPAREN "operator" "this" "true"
// "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near"
// "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_21(
    _tokenSet_21_data_, 12);
const unsigned long CPPParser::_tokenSet_22_data_[] = {256UL, 0UL, 0UL, 0UL,
                                                       0UL,   0UL, 0UL, 0UL};
// SEMICOLON
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_22(
    _tokenSet_22_data_, 8);
const unsigned long CPPParser::_tokenSet_23_data_[] = {
    101188864UL, 1UL, 1910505472UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// SEMICOLON ID COLON "_stdcall" "__stdcall" LPAREN "operator" "this" "true"
// "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near"
// "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_23(
    _tokenSet_23_data_, 12);
const unsigned long CPPParser::_tokenSet_24_data_[] = {
    101582176UL, 3UL, 4259446784UL, 4293918720UL, 557055UL, 16368UL,
    0UL,         0UL, 0UL,          0UL,          0UL,      0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON "_stdcall"
// "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE
// RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl" "__cdecl" "_near" "__near"
// "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_24(
    _tokenSet_24_data_, 12);
const unsigned long CPPParser::_tokenSet_25_data_[] = {
    100664320UL, 0UL, 1610612736UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// ID "_stdcall" "__stdcall" STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near"
// "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_25(
    _tokenSet_25_data_, 12);
const unsigned long CPPParser::_tokenSet_26_data_[] = {
    100664352UL, 1UL, 1642131456UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// LESSTHAN ID "_stdcall" "__stdcall" LPAREN "const" "__const" "volatile"
// "__volatile__" "operator" "this" "true" "false" STAR AMPERSAND SCOPE
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_26(
    _tokenSet_26_data_, 12);
const unsigned long CPPParser::_tokenSet_27_data_[] = {
    1024UL, 1UL, 31457280UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID LPAREN "operator" "this" "true" "false" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_27(
    _tokenSet_27_data_, 12);
const unsigned long CPPParser::_tokenSet_28_data_[] = {
    263264UL, 1UL, 1977745408UL, 3220176896UL, 2744319UL, 16396UL,
    0UL,      0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN ID ASSIGNEQUAL LPAREN COMMA "operator" "this" "true"
// "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR
// PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_28(
    _tokenSet_28_data_, 12);
const unsigned long CPPParser::_tokenSet_29_data_[] = {
    4291837824UL, 4294967292UL, 65535UL, 2UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,     0UL, 0UL,      0UL};
// "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "extern" "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register"
// "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename"
// "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16"
// "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "using" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_29(
    _tokenSet_29_data_, 12);
const unsigned long CPPParser::_tokenSet_30_data_[] = {
    4294180754UL, 4294967293UL, 1945960447UL, 1015807UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// EOF "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend"
// "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral
// "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE"
// "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" "public" "protected"
// "private" "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND
// "throw" "using" "case" "default" "if" "else" "switch" "while" "do" "for"
// "goto" "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__"
// PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_30(
    _tokenSet_30_data_, 12);
const unsigned long CPPParser::_tokenSet_31_data_[] = {
    4291835520UL, 4294967293UL, 1910571007UL, 2UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND
// "using" SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_31(
    _tokenSet_31_data_, 12);
const unsigned long CPPParser::_tokenSet_32_data_[] = {2304UL, 0UL, 0UL, 0UL,
                                                       0UL,    0UL, 0UL, 0UL};
// SEMICOLON LCURLY
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_32(
    _tokenSet_32_data_, 8);
const unsigned long CPPParser::_tokenSet_33_data_[] = {
    1024UL, 0UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_33(
    _tokenSet_33_data_, 12);
const unsigned long CPPParser::_tokenSet_34_data_[] = {
    1024UL, 0UL, 836763648UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID "operator" "this" "true" "false" TILDE STAR
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_34(
    _tokenSet_34_data_, 8);
const unsigned long CPPParser::_tokenSet_35_data_[] = {
    4291837568UL, 4294967292UL, 65535UL, 2UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,     0UL, 0UL,      0UL};
// "typedef" "enum" ID LCURLY "inline" "friend" "extern" "struct" "union"
// "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static"
// "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char"
// "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16"
// "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t"
// "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed"
// "unsigned" "float" "double" "void" "_declspec" "__declspec" "const"
// "__const" "volatile" "__volatile__" "using" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_35(
    _tokenSet_35_data_, 12);
const unsigned long CPPParser::_tokenSet_36_data_[] = {
    4294180784UL, 4294967293UL, 1945960447UL, 1015775UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// "template" LESSTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend"
// "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral
// "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE"
// "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" "public" "protected"
// "private" "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND
// "throw" "using" "case" "default" "if" "switch" "while" "do" "for" "goto"
// "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS
// MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_36(
    _tokenSet_36_data_, 12);
const unsigned long CPPParser::_tokenSet_37_data_[] = {
    4294180752UL, 4294967293UL, 1945960447UL, 1015775UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace"
// "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "public" "protected" "private"
// "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw"
// "using" "case" "default" "if" "switch" "while" "do" "for" "goto" "continue"
// "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS MINUS PLUSPLUS
// MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast"
// "reinterpret_cast" "const_cast" "typeid" DECIMALINT HEXADECIMALINT
// CharLiteral
// WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl"
// "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
// "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_37(
    _tokenSet_37_data_, 12);
const unsigned long CPPParser::_tokenSet_38_data_[] = {
    100664320UL, 1UL, 1642070016UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// ID "_stdcall" "__stdcall" LPAREN "operator" "this" "true" "false" STAR
// AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_38(
    _tokenSet_38_data_, 12);
const unsigned long CPPParser::_tokenSet_39_data_[] = {
    100926560UL, 1UL, 1977806848UL, 3220176896UL, 2744319UL, 32764UL,
    0UL,         0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN ID ASSIGNEQUAL "_stdcall" "__stdcall" LPAREN "const"
// "__const" "volatile" "__volatile__" COMMA "operator" "this" "true" "false"
// LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL
// MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL
// BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR
// PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT "new" "_cdecl" "__cdecl" "_near"
// "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
// "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_39(
    _tokenSet_39_data_, 12);
const unsigned long CPPParser::_tokenSet_40_data_[] = {
    4294180752UL, 4294967293UL, 1945960447UL, 1015807UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace"
// "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "public" "protected" "private"
// "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw"
// "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto"
// "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS
// MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_40(
    _tokenSet_40_data_, 12);
const unsigned long CPPParser::_tokenSet_41_data_[] = {
    101453120UL, 3UL, 4125229056UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// GREATERTHAN SEMICOLON ID LCURLY ASSIGNEQUAL COLON "_stdcall" "__stdcall"
// LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE TILDE STAR
// AMPERSAND ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far"
// "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_41(
    _tokenSet_41_data_, 12);
const unsigned long CPPParser::_tokenSet_42_data_[] = {
    5120UL, 1792UL, 268435456UL, 0UL, 524288UL, 0UL,
    0UL,    0UL,    0UL,         0UL, 0UL,      0UL};
// ID "inline" "_inline" "__inline" "virtual" TILDE SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_42(
    _tokenSet_42_data_, 12);
const unsigned long CPPParser::_tokenSet_43_data_[] = {
    4291835520UL, 4294967292UL, 2162687UL, 0UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,       0UL, 0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "operator" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_43(
    _tokenSet_43_data_, 12);
const unsigned long CPPParser::_tokenSet_44_data_[] = {
    1024UL, 0UL, 31457280UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID "operator" "this" "true" "false" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_44(
    _tokenSet_44_data_, 12);
const unsigned long CPPParser::_tokenSet_45_data_[] = {
    263520UL, 1UL, 1977745408UL, 3220176896UL, 2744319UL, 16396UL,
    0UL,      0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL LPAREN COMMA "operator"
// "this" "true" "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL
// MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL
// EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS
// MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT
// "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_45(
    _tokenSet_45_data_, 12);
const unsigned long CPPParser::_tokenSet_46_data_[] = {
    100668416UL, 3841UL, 1642070016UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL,    0UL,          0UL, 0UL,      0UL};
// ID "inline" "_stdcall" "__stdcall" LPAREN "_inline" "__inline" "virtual"
// "explicit" "operator" "this" "true" "false" STAR AMPERSAND SCOPE "_cdecl"
// "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal"
// "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_46(
    _tokenSet_46_data_, 12);
const unsigned long CPPParser::_tokenSet_47_data_[] = {
    100930656UL, 3841UL, 1977806848UL, 3220176896UL, 2744319UL, 32764UL,
    0UL,         0UL,    0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN ID "inline" ASSIGNEQUAL "_stdcall" "__stdcall"
// LPAREN "_inline" "__inline" "virtual" "explicit" "const" "__const" "volatile"
// "__volatile__" COMMA "operator" "this" "true" "false" LSQUARE TILDE
// STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL
// SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL
// OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO
// SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS
// SCOPE POINTERTO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far"
// "__far" "__interrupt" "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_47(
    _tokenSet_47_data_, 12);
const unsigned long CPPParser::_tokenSet_48_data_[] = {526592UL, 0UL, 0UL, 0UL,
                                                       0UL,      0UL, 0UL, 0UL};
// SEMICOLON LCURLY COLON
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_48(
    _tokenSet_48_data_, 8);
const unsigned long CPPParser::_tokenSet_49_data_[] = {
    4294049680UL, 4294967293UL, 1945960447UL, 1015775UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace"
// "antlrTrace_on" "antlrTrace_off" "extern" StringLiteral "struct" "union"
// "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register"
// "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename"
// "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16"
// "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "public" "protected" "private"
// "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw"
// "using" "case" "default" "if" "switch" "while" "do" "for" "goto" "continue"
// "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS MINUS PLUSPLUS
// MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast"
// "reinterpret_cast" "const_cast" "typeid" DECIMALINT HEXADECIMALINT
// CharLiteral
// WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl"
// "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
// "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_49(
    _tokenSet_49_data_, 12);
const unsigned long CPPParser::_tokenSet_50_data_[] = {
    4294180754UL, 4294967293UL, 1945960447UL, 1048575UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// EOF "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend"
// "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral
// "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE"
// "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" "public" "protected"
// "private" "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND
// "throw" "using" "case" "default" "if" "else" "switch" "while" "do" "for"
// "goto" "continue" "break" "return" "try" "catch" "asm" "_asm" "__asm"
// "__asm__" PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE
// "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid"
// DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE
// FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt" "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_50(
    _tokenSet_50_data_, 12);
const unsigned long CPPParser::_tokenSet_51_data_[] = {
    525312UL, 1024UL, 0UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID COLON "virtual" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_51(
    _tokenSet_51_data_, 12);
const unsigned long CPPParser::_tokenSet_52_data_[] = {64UL, 0UL, 0UL, 0UL,
                                                       0UL,  0UL, 0UL, 0UL};
// GREATERTHAN
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_52(
    _tokenSet_52_data_, 8);
const unsigned long CPPParser::_tokenSet_53_data_[] = {2048UL, 0UL, 0UL, 0UL,
                                                       0UL,    0UL, 0UL, 0UL};
// LCURLY
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_53(
    _tokenSet_53_data_, 8);
const unsigned long CPPParser::_tokenSet_54_data_[] = {
    4292755424UL, 4294967295UL, 4259512319UL, 4293918723UL, 557055UL, 16368UL,
    0UL,          0UL,          0UL,          0UL,          0UL,      0UL};
// LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend"
// RCURLY ASSIGNEQUAL COLON "extern" "struct" "union" "class" "_stdcall"
// "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE"
// LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static"
// "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char"
// "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16"
// "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t"
// "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed"
// "unsigned" "float" "double" "void" "_declspec" "__declspec" "const"
// "__const" "volatile" "__volatile__" COMMA "operator" "this" "true" "false"
// LSQUARE RSQUARE TILDE STAR AMPERSAND ELLIPSIS "throw" "using" TIMESEQUAL
// DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL
// BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR
// BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT
// SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl"
// "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal"
// "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_54(
    _tokenSet_54_data_, 12);
const unsigned long CPPParser::_tokenSet_55_data_[] = {
    4293932672UL, 4294967293UL, 1944125439UL, 0UL, 4291790336UL, 16399UL,
    0UL,          0UL,          0UL,          0UL, 0UL,          0UL};
// "typedef" "enum" ID "inline" "friend" "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "operator" "this" "true"
// "false" OCTALINT TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS
// "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast" "reinterpret_cast"
// "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral
// WStringLiteral FLOATONE FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_55(
    _tokenSet_55_data_, 12);
const unsigned long CPPParser::_tokenSet_56_data_[] = {
    101584224UL, 3UL, 4259446784UL, 4293918720UL, 557055UL, 16368UL,
    0UL,         0UL, 0UL,          0UL,          0UL,      0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID LCURLY RCURLY ASSIGNEQUAL COLON "_stdcall"
// "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE
// RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl" "__cdecl" "_near" "__near"
// "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_56(
    _tokenSet_56_data_, 12);
const unsigned long CPPParser::_tokenSet_57_data_[] = {
    4294967282UL, 4294967295UL, 4294967295UL, 4294934527UL,
    4294967295UL, 32767UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// EOF "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY
// "inline" "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY
// ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class" "_stdcall"
// "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE"
// LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static"
// "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char"
// "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16"
// "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t"
// "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed"
// "unsigned" "float" "double" "void" "_declspec" "__declspec" "const"
// "__const" "volatile" "__volatile__" "GFIGNORE" COMMA "public" "protected"
// "private" "operator" "this" "true" "false" OCTALINT LSQUARE RSQUARE
// TILDE STAR AMPERSAND ELLIPSIS "throw" "using" "case" "default" "if"
// "else" "switch" "while" "do" "for" "goto" "continue" "break" "return"
// "try" "asm" "_asm" "__asm" "__asm__" TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__"
// SCOPE DOT POINTERTO "dynamic_cast" "static_cast" "reinterpret_cast"
// "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral
// WStringLiteral FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near"
// "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
// "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_57(
    _tokenSet_57_data_, 12);
const unsigned long CPPParser::_tokenSet_58_data_[] = {
    3072UL, 0UL, 31522816UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID LCURLY "GFIGNORE" "operator" "this" "true" "false" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_58(
    _tokenSet_58_data_, 12);
const unsigned long CPPParser::_tokenSet_59_data_[] = {
    524544UL, 2UL, 134217728UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// SEMICOLON COLON RPAREN RSQUARE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_59(
    _tokenSet_59_data_, 8);
const unsigned long CPPParser::_tokenSet_60_data_[] = {
    2048UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// LCURLY COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_60(
    _tokenSet_60_data_, 8);
const unsigned long CPPParser::_tokenSet_61_data_[] = {131072UL, 0UL, 0UL, 0UL,
                                                       0UL,      0UL, 0UL, 0UL};
// RCURLY
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_61(
    _tokenSet_61_data_, 8);
const unsigned long CPPParser::_tokenSet_62_data_[] = {
    131072UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// RCURLY COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_62(
    _tokenSet_62_data_, 8);
const unsigned long CPPParser::_tokenSet_63_data_[] = {
    917760UL, 0UL, 134348800UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// SEMICOLON RCURLY ASSIGNEQUAL COLON COMMA RSQUARE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_63(
    _tokenSet_63_data_, 8);
const unsigned long CPPParser::_tokenSet_64_data_[] = {
    101584224UL, 3UL, 4259446784UL, 4293918720UL, 3801087UL, 16368UL,
    0UL,         0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID LCURLY RCURLY ASSIGNEQUAL COLON "_stdcall"
// "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE
// RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE DOT POINTERTO
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_64(
    _tokenSet_64_data_, 12);
const unsigned long CPPParser::_tokenSet_65_data_[] = {
    256UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// SEMICOLON COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_65(
    _tokenSet_65_data_, 8);
const unsigned long CPPParser::_tokenSet_66_data_[] = {
    100664352UL, 1UL, 1910566912UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// LESSTHAN ID "_stdcall" "__stdcall" LPAREN "const" "__const" "volatile"
// "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND
// SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_66(
    _tokenSet_66_data_, 12);
const unsigned long CPPParser::_tokenSet_67_data_[] = {
    1024UL, 1UL, 299892736UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID LPAREN "operator" "this" "true" "false" TILDE SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_67(
    _tokenSet_67_data_, 12);
const unsigned long CPPParser::_tokenSet_68_data_[] = {
    100926816UL, 3UL, 4125229056UL, 3220176896UL, 2744319UL, 32764UL,
    0UL,         0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL "_stdcall" "__stdcall"
// LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE TILDE STAR
// AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL
// SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL
// OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO
// SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS
// SCOPE POINTERTO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far"
// "__far" "__interrupt" "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_68(
    _tokenSet_68_data_, 12);
const unsigned long CPPParser::_tokenSet_69_data_[] = {
    262464UL, 3UL, 2147614720UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN SEMICOLON ASSIGNEQUAL LPAREN RPAREN COMMA ELLIPSIS
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_69(
    _tokenSet_69_data_, 8);
const unsigned long CPPParser::_tokenSet_70_data_[] = {
    131328UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// SEMICOLON RCURLY COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_70(
    _tokenSet_70_data_, 8);
const unsigned long CPPParser::_tokenSet_71_data_[] = {0UL, 2UL, 0UL, 0UL,
                                                       0UL, 0UL, 0UL, 0UL};
// RPAREN
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_71(
    _tokenSet_71_data_, 8);
const unsigned long CPPParser::_tokenSet_72_data_[] = {
    2098176UL, 4294963201UL, 1944063999UL, 0UL, 4291790336UL, 16399UL,
    0UL,       0UL,          0UL,          0UL, 0UL,          0UL};
// ID StringLiteral LPAREN "typename" "char" "wchar_t" "bool" "short" "int"
// "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32"
// "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t"
// "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double"
// "void" "_declspec" "__declspec" "operator" "this" "true" "false" OCTALINT
// TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__"
// SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid"
// DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE
// FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_72(
    _tokenSet_72_data_, 12);
const unsigned long CPPParser::_tokenSet_73_data_[] = {
    4294850528UL, 4294967295UL, 4293066751UL, 4293918720UL,
    4294967295UL, 16399UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID "inline" "friend"
// RCURLY ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static"
// "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char"
// "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16"
// "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t"
// "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed"
// "unsigned" "float" "double" "void" "_declspec" "__declspec" "const"
// "__const" "volatile" "__volatile__" COMMA "operator" "this" "true" "false"
// OCTALINT LSQUARE RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL
// MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR
// NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT
// PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof"
// "__alignof__" SCOPE DOT POINTERTO "dynamic_cast" "static_cast"
// "reinterpret_cast"
// "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral
// WStringLiteral FLOATONE FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_73(
    _tokenSet_73_data_, 12);
const unsigned long CPPParser::_tokenSet_74_data_[] = {
    655680UL, 2UL, 2281832448UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY COLON RPAREN COMMA RSQUARE ELLIPSIS
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_74(
    _tokenSet_74_data_, 8);
const unsigned long CPPParser::_tokenSet_75_data_[] = {
    2622464UL, 4294963201UL, 1944063999UL, 0UL, 4291790336UL, 16399UL,
    0UL,       0UL,          0UL,          0UL, 0UL,          0UL};
// ID COLON StringLiteral LPAREN "typename" "char" "wchar_t" "bool" "short"
// "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32"
// "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t"
// "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float"
// "double" "void" "_declspec" "__declspec" "operator" "this" "true" "false"
// OCTALINT TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS "sizeof"
// "__alignof__" SCOPE "dynamic_cast" "static_cast" "reinterpret_cast"
// "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral
// WStringLiteral FLOATONE FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_75(
    _tokenSet_75_data_, 12);
const unsigned long CPPParser::_tokenSet_76_data_[] = {
    100664320UL, 1UL, 1910505472UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// ID "_stdcall" "__stdcall" LPAREN "operator" "this" "true" "false" TILDE
// STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_76(
    _tokenSet_76_data_, 12);
const unsigned long CPPParser::_tokenSet_77_data_[] = {
    100926816UL, 1UL, 1977806848UL, 3220176896UL, 2744319UL, 32764UL,
    0UL,         0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL "_stdcall" "__stdcall"
// LPAREN "const" "__const" "volatile" "__volatile__" COMMA "operator"
// "this" "true" "false" LSQUARE TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL
// MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL
// EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS
// MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT
// "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt"
// "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_77(
    _tokenSet_77_data_, 12);
const unsigned long CPPParser::_tokenSet_78_data_[] = {
    262400UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// SEMICOLON ASSIGNEQUAL COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_78(
    _tokenSet_78_data_, 8);
const unsigned long CPPParser::_tokenSet_79_data_[] = {
    4293932672UL, 4294967295UL, 4225826815UL, 0UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL, 0UL,          0UL};
// "typedef" "enum" ID "inline" "friend" "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" "operator"
// "this" "true" "false" OCTALINT RSQUARE TILDE STAR AMPERSAND ELLIPSIS
// PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_79(
    _tokenSet_79_data_, 12);
const unsigned long CPPParser::_tokenSet_80_data_[] = {
    4294967250UL, 4294967295UL, 4160684031UL, 1015807UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// EOF "template" GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline"
// "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY ASSIGNEQUAL
// COLON "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall"
// "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN
// "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" COMMA "public" "protected" "private" "operator" "this"
// "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND ELLIPSIS "throw"
// "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto"
// "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" PLUS
// MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_80(
    _tokenSet_80_data_, 12);
const unsigned long CPPParser::_tokenSet_81_data_[] = {
    263520UL, 3UL, 4125229056UL, 3220176896UL, 2744319UL, 16396UL,
    0UL,      0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID ASSIGNEQUAL LPAREN RPAREN COMMA "operator"
// "this" "true" "false" LSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL
// DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL
// BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR
// NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT
// PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO
// NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_81(
    _tokenSet_81_data_, 12);
const unsigned long CPPParser::_tokenSet_82_data_[] = {
    4292624320UL, 4294967295UL, 2147680255UL, 2UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend"
// ASSIGNEQUAL
// COLON "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE"
// "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES"
// "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline"
// "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int"
// "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32"
// "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t"
// "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double"
// "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__"
// COMMA ELLIPSIS "using" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_82(
    _tokenSet_82_data_, 12);
const unsigned long CPPParser::_tokenSet_83_data_[] = {
    4292099968UL, 4294967292UL, 65535UL, 3UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,     0UL, 0UL,      0UL};
// "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" ASSIGNEQUAL "extern"
// "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE"
// "GFID" "GFUNREAD" "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "throw" "using" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_83(
    _tokenSet_83_data_, 12);
const unsigned long CPPParser::_tokenSet_84_data_[] = {526336UL, 0UL, 0UL, 0UL,
                                                       0UL,      0UL, 0UL, 0UL};
// LCURLY COLON
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_84(
    _tokenSet_84_data_, 8);
const unsigned long CPPParser::_tokenSet_85_data_[] = {0UL, 1UL, 0UL, 0UL,
                                                       0UL, 0UL, 0UL, 0UL};
// LPAREN
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_85(
    _tokenSet_85_data_, 8);
const unsigned long CPPParser::_tokenSet_86_data_[] = {
    1024UL, 0UL, 268435456UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// ID TILDE SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_86(
    _tokenSet_86_data_, 12);
const unsigned long CPPParser::_tokenSet_87_data_[] = {
    0UL, 2UL, 2147483648UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// RPAREN ELLIPSIS
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_87(
    _tokenSet_87_data_, 8);
const unsigned long CPPParser::_tokenSet_88_data_[] = {
    4292097760UL, 4294967295UL, 4125294591UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL
// "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE"
// "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES"
// "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline"
// "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int"
// "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32"
// "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t"
// "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double"
// "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__"
// COMMA "operator" "this" "true" "false" LSQUARE TILDE STAR AMPERSAND
// ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_88(
    _tokenSet_88_data_, 12);
const unsigned long CPPParser::_tokenSet_89_data_[] = {
    100926560UL, 3UL, 4125290496UL, 3220176896UL, 2744319UL, 32764UL,
    0UL,         0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN ID ASSIGNEQUAL "_stdcall" "__stdcall" LPAREN RPAREN
// "const" "__const" "volatile" "__volatile__" COMMA "operator" "this"
// "true" "false" LSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL
// MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR NOTEQUAL
// EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS
// MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS SCOPE POINTERTO NOT
// "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt"
// "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_89(
    _tokenSet_89_data_, 12);
const unsigned long CPPParser::_tokenSet_90_data_[] = {
    100926528UL, 3UL, 3825336320UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// GREATERTHAN ID ASSIGNEQUAL "_stdcall" "__stdcall" LPAREN RPAREN COMMA
// LSQUARE STAR AMPERSAND ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near"
// "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_90(
    _tokenSet_90_data_, 12);
const unsigned long CPPParser::_tokenSet_91_data_[] = {
    4294721520UL, 4294967295UL, 4293066751UL, 3UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL, 0UL,          0UL};
// "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY
// "inline" "friend" ASSIGNEQUAL COLON "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" COMMA "operator"
// "this" "true" "false" OCTALINT LSQUARE RSQUARE TILDE STAR AMPERSAND
// ELLIPSIS "throw" "using" PLUS MINUS PLUSPLUS MINUSMINUS "sizeof"
// "__alignof__"
// SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid"
// DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE
// FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt" "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_91(
    _tokenSet_91_data_, 12);
const unsigned long CPPParser::_tokenSet_92_data_[] = {
    64UL, 2UL, 2147614720UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN RPAREN COMMA ELLIPSIS
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_92(
    _tokenSet_92_data_, 8);
const unsigned long CPPParser::_tokenSet_93_data_[] = {
    262208UL, 3UL, 2214723584UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN ASSIGNEQUAL LPAREN RPAREN COMMA LSQUARE ELLIPSIS
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_93(
    _tokenSet_93_data_, 8);
const unsigned long CPPParser::_tokenSet_94_data_[] = {
    4294852594UL, 4294967295UL, 4293066751UL, 4293918723UL,
    4291821567UL, 32767UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// EOF "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY
// "inline" "friend" RCURLY ASSIGNEQUAL COLON "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" COMMA "operator"
// "this" "true" "false" OCTALINT LSQUARE RSQUARE TILDE STAR AMPERSAND
// ELLIPSIS "throw" "using" TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL
// MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__"
// SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid"
// DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE
// FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt" "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_94(
    _tokenSet_94_data_, 12);
const unsigned long CPPParser::_tokenSet_95_data_[] = {
    262208UL, 2UL, 2147614720UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN ASSIGNEQUAL RPAREN COMMA ELLIPSIS
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_95(
    _tokenSet_95_data_, 8);
const unsigned long CPPParser::_tokenSet_96_data_[] = {
    64UL, 2UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN RPAREN COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_96(
    _tokenSet_96_data_, 8);
const unsigned long CPPParser::_tokenSet_97_data_[] = {
    101582176UL, 3UL, 4259446784UL, 4293918721UL, 557055UL, 16368UL,
    0UL,         0UL, 0UL,          0UL,          0UL,      0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON "_stdcall"
// "__stdcall" LPAREN RPAREN COMMA "operator" "this" "true" "false" LSQUARE
// RSQUARE TILDE STAR AMPERSAND ELLIPSIS "throw" TIMESEQUAL DIVIDEEQUAL
// MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR
// NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT
// PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR SCOPE "_cdecl" "__cdecl" "_near"
// "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_97(
    _tokenSet_97_data_, 12);
const unsigned long CPPParser::_tokenSet_98_data_[] = {
    16777232UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// "template" "class" "typename"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_98(
    _tokenSet_98_data_, 8);
const unsigned long CPPParser::_tokenSet_99_data_[] = {
    1120UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// LESSTHAN GREATERTHAN ID COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_99(
    _tokenSet_99_data_, 8);
const unsigned long CPPParser::_tokenSet_100_data_[] = {
    4291835520UL, 4294967293UL, 4058054655UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "operator" "this" "true" "false" TILDE STAR AMPERSAND
// ELLIPSIS SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_100(
    _tokenSet_100_data_, 12);
const unsigned long CPPParser::_tokenSet_101_data_[] = {
    64UL, 0UL, 131072UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN COMMA
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_101(
    _tokenSet_101_data_, 8);
const unsigned long CPPParser::_tokenSet_102_data_[] = {
    100664416UL, 1UL, 1677852672UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// LESSTHAN GREATERTHAN ID "_stdcall" "__stdcall" LPAREN COMMA LSQUARE
// STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_102(
    _tokenSet_102_data_, 12);
const unsigned long CPPParser::_tokenSet_103_data_[] = {
    1024UL, 4294963200UL, 4095UL, 0UL, 524288UL, 0UL,
    0UL,    0UL,          0UL,    0UL, 0UL,      0UL};
// ID "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8"
// "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64"
// "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64"
// "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_103(
    _tokenSet_103_data_, 12);
const unsigned long CPPParser::_tokenSet_104_data_[] = {
    100664416UL, 4294959105UL, 1677856767UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN GREATERTHAN ID "_stdcall" "__stdcall" LPAREN "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" COMMA LSQUARE STAR
// AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt"
// "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_104(
    _tokenSet_104_data_, 12);
const unsigned long CPPParser::_tokenSet_105_data_[] = {
    4291835616UL, 4294967293UL, 1677918207UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" "extern"
// "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE"
// "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" COMMA LSQUARE
// STAR AMPERSAND SCOPE "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_105(
    _tokenSet_105_data_, 12);
const unsigned long CPPParser::_tokenSet_106_data_[] = {
    4294194912UL, 4294967293UL, 2011365375UL, 3220176896UL,
    4294967295UL, 16399UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL
// "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall"
// "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES"
// "GFARRAYELEMSIZE" "auto" "register" "static" "mutable" "_inline" "__inline"
// "virtual" "explicit" "typename" "char" "wchar_t" "bool" "short" "int"
// "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32"
// "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t"
// "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double"
// "void" "_declspec" "__declspec" "const" "__const" "volatile" "__volatile__"
// COMMA "operator" "this" "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND
// TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL OR AND
// BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO
// SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS
// MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_106(
    _tokenSet_106_data_, 12);
const unsigned long CPPParser::_tokenSet_107_data_[] = {
    917856UL, 2UL, 3355574272UL, 4293918720UL, 127UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,   0UL};
// LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA
// RSQUARE AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL
// MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_107(
    _tokenSet_107_data_, 12);
const unsigned long CPPParser::_tokenSet_108_data_[] = {
    4291851904UL, 4294967292UL, 65535UL, 983042UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,     0UL,      0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "namespace" "extern" "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register"
// "static" "mutable" "_inline" "__inline" "virtual" "explicit" "typename"
// "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16"
// "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "using" "asm" "_asm" "__asm"
// "__asm__" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_108(
    _tokenSet_108_data_, 12);
const unsigned long CPPParser::_tokenSet_109_data_[] = {
    4291852192UL, 4294967293UL, 1910571007UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN "typedef" SEMICOLON "enum" ID "inline" "friend" "namespace"
// "extern" "struct" "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE"
// "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES"
// "GFARRAYELEMSIZE"
// "auto" "register" "static" "mutable" "_inline" "__inline" "virtual"
// "explicit" "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" "operator"
// "this" "true" "false" TILDE STAR AMPERSAND SCOPE "_cdecl" "__cdecl"
// "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_109(
    _tokenSet_109_data_, 12);
const unsigned long CPPParser::_tokenSet_110_data_[] = {
    4294967280UL, 4294967293UL, 2013265919UL, 3221192703UL,
    4293910527UL, 32767UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY
// "inline" "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY
// ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class" "_stdcall"
// "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "GFIGNORE" COMMA "public" "protected" "private" "operator"
// "this" "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND "throw"
// "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto"
// "continue" "break" "return" "try" "asm" "_asm" "__asm" "__asm__" TIMESEQUAL
// DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL
// BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL OR AND BITWISEOR BITWISEXOR
// NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT
// PLUS MINUS DIVIDE MOD POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__"
// SCOPE POINTERTO "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast"
// "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral
// FLOATONE FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far"
// "__far" "__interrupt" "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_110(
    _tokenSet_110_data_, 12);
const unsigned long CPPParser::_tokenSet_111_data_[] = {
    1056UL, 0UL, 568389632UL, 0UL, 524288UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// LESSTHAN ID "const" "__const" "volatile" "__volatile__" "operator" "this"
// "true" "false" STAR SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_111(
    _tokenSet_111_data_, 12);
const unsigned long CPPParser::_tokenSet_112_data_[] = {
    4294195168UL, 4294967293UL, 2011365375UL, 4293918720UL,
    4294967295UL, 16399UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID "inline" "friend"
// ASSIGNEQUAL "extern" StringLiteral "struct" "union" "class" "_stdcall"
// "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE
// TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL
// SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL
// QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR
// POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO
// "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid"
// DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE
// FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_112(
    _tokenSet_112_data_, 12);
const unsigned long CPPParser::_tokenSet_113_data_[] = {
    4294967282UL, 4294967293UL, 2013265919UL, 4294967295UL,
    4294967295UL, 32767UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// EOF "template" LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID LCURLY
// "inline" "friend" "namespace" "antlrTrace_on" "antlrTrace_off" RCURLY
// ASSIGNEQUAL COLON "extern" StringLiteral "struct" "union" "class" "_stdcall"
// "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" "GFIGNORE" COMMA "public" "protected" "private" "operator"
// "this" "true" "false" OCTALINT LSQUARE TILDE STAR AMPERSAND "throw"
// "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto"
// "continue" "break" "return" "try" "catch" "asm" "_asm" "__asm" "__asm__"
// TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK
// OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO
// SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS
// MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_113(
    _tokenSet_113_data_, 12);
const unsigned long CPPParser::_tokenSet_114_data_[] = {
    4294180752UL, 4294967293UL, 1945960447UL, 1048575UL, 4291790336UL, 32767UL,
    0UL,          0UL,          0UL,          0UL,       0UL,          0UL};
// "template" "typedef" SEMICOLON "enum" ID LCURLY "inline" "friend" "namespace"
// "antlrTrace_on" "antlrTrace_off" RCURLY "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "public" "protected" "private"
// "operator" "this" "true" "false" OCTALINT TILDE STAR AMPERSAND "throw"
// "using" "case" "default" "if" "else" "switch" "while" "do" "for" "goto"
// "continue" "break" "return" "try" "catch" "asm" "_asm" "__asm" "__asm__"
// PLUS MINUS PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE "dynamic_cast"
// "static_cast" "reinterpret_cast" "const_cast" "typeid" DECIMALINT
// HEXADECIMALINT
// CharLiteral WCharLiteral WStringLiteral FLOATONE FLOATTWO NOT "new"
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_114(
    _tokenSet_114_data_, 12);
const unsigned long CPPParser::_tokenSet_115_data_[] = {
    917824UL, 2UL, 2281832448UL, 1072693248UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_115(
    _tokenSet_115_data_, 8);
const unsigned long CPPParser::_tokenSet_116_data_[] = {
    917824UL, 2UL, 2281832448UL, 2146435072UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_116(
    _tokenSet_116_data_, 8);
const unsigned long CPPParser::_tokenSet_117_data_[] = {
    917824UL, 2UL, 2281832448UL, 4293918720UL, 0UL, 0UL, 0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK
// OR
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_117(
    _tokenSet_117_data_, 8);
const unsigned long CPPParser::_tokenSet_118_data_[] = {
    917824UL, 2UL, 2281832448UL, 4293918720UL, 1UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK
// OR AND
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_118(
    _tokenSet_118_data_, 12);
const unsigned long CPPParser::_tokenSet_119_data_[] = {
    917824UL, 2UL, 2281832448UL, 4293918720UL, 3UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK
// OR AND BITWISEOR
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_119(
    _tokenSet_119_data_, 12);
const unsigned long CPPParser::_tokenSet_120_data_[] = {
    917824UL, 2UL, 2281832448UL, 4293918720UL, 7UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK
// OR AND BITWISEOR BITWISEXOR
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_120(
    _tokenSet_120_data_, 12);
const unsigned long CPPParser::_tokenSet_121_data_[] = {
    917824UL, 2UL, 3355574272UL, 4293918720UL, 7UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL, 0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL
// SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL
// QUESTIONMARK OR AND BITWISEOR BITWISEXOR
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_121(
    _tokenSet_121_data_, 12);
const unsigned long CPPParser::_tokenSet_122_data_[] = {
    96UL, 0UL, 0UL, 0UL, 96UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// LESSTHAN GREATERTHAN LESSTHANOREQUALTO GREATERTHANOREQUALTO
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_122(
    _tokenSet_122_data_, 12);
const unsigned long CPPParser::_tokenSet_123_data_[] = {
    917824UL, 2UL, 3355574272UL, 4293918720UL, 31UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,  0UL};
// GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA RSQUARE
// AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL
// SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL
// QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_123(
    _tokenSet_123_data_, 12);
const unsigned long CPPParser::_tokenSet_124_data_[] = {
    917856UL, 2UL, 3355574272UL, 4293918720UL, 511UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,   0UL};
// LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA
// RSQUARE AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL
// MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_124(
    _tokenSet_124_data_, 12);
const unsigned long CPPParser::_tokenSet_125_data_[] = {
    0UL, 0UL, 536870912UL, 0UL, 6144UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// STAR DIVIDE MOD
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_125(
    _tokenSet_125_data_, 12);
const unsigned long CPPParser::_tokenSet_126_data_[] = {
    917856UL, 2UL, 3355574272UL, 4293918720UL, 2047UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,    0UL};
// LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA
// RSQUARE AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL
// MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_126(
    _tokenSet_126_data_, 12);
const unsigned long CPPParser::_tokenSet_127_data_[] = {
    917856UL, 2UL, 3892445184UL, 4293918720UL, 8191UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,    0UL};
// LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA
// RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL
// MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_127(
    _tokenSet_127_data_, 12);
const unsigned long CPPParser::_tokenSet_128_data_[] = {
    1024UL, 4294963200UL, 65535UL, 0UL, 524288UL, 0UL,
    0UL,    0UL,          0UL,     0UL, 0UL,      0UL};
// ID "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8"
// "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64"
// "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64"
// "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" "const" "__const" "volatile" "__volatile__" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_128(
    _tokenSet_128_data_, 12);
const unsigned long CPPParser::_tokenSet_129_data_[] = {
    917856UL, 2UL, 3892445184UL, 4293918720UL, 32767UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,     0UL};
// LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON RPAREN COMMA
// RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL
// MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_129(
    _tokenSet_129_data_, 12);
const unsigned long CPPParser::_tokenSet_130_data_[] = {
    2098176UL, 4294963201UL, 333451263UL, 0UL, 4291297280UL, 3UL,
    0UL,       0UL,          0UL,         0UL, 0UL,          0UL};
// ID StringLiteral LPAREN "typename" "char" "wchar_t" "bool" "short" "int"
// "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32"
// "int32_t" "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t"
// "uint64_t" "_w64" "__w64" "long" "signed" "unsigned" "float" "double"
// "void" "_declspec" "__declspec" "operator" "this" "true" "false" OCTALINT
// TILDE SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast"
// "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral
// FLOATONE FLOATTWO
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_130(
    _tokenSet_130_data_, 12);
const unsigned long CPPParser::_tokenSet_131_data_[] = {
    3016032UL, 4294963203UL, 4293005311UL, 4293918720UL, 4294967295UL, 16399UL,
    0UL,       0UL,          0UL,          0UL,          0UL,          0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON StringLiteral
// LPAREN RPAREN "typename" "char" "wchar_t" "bool" "short" "int" "_int8"
// "__int8" "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t"
// "_int64" "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t"
// "_w64" "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE
// RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__"
// SCOPE DOT POINTERTO "dynamic_cast" "static_cast" "reinterpret_cast"
// "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral
// WStringLiteral FLOATONE FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_131(
    _tokenSet_131_data_, 12);
const unsigned long CPPParser::_tokenSet_132_data_[] = {
    0UL, 0UL, 1879048192UL, 0UL, 1536UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// TILDE STAR AMPERSAND PLUS MINUS NOT
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_132(
    _tokenSet_132_data_, 12);
const unsigned long CPPParser::_tokenSet_133_data_[] = {
    0UL, 0UL, 0UL, 0UL, 524288UL, 16392UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL};
// SCOPE "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_133(
    _tokenSet_133_data_, 12);
const unsigned long CPPParser::_tokenSet_134_data_[] = {
    4293932672UL, 4294967293UL, 2011234303UL, 0UL, 4291790336UL, 16399UL,
    0UL,          0UL,          0UL,          0UL, 0UL,          0UL};
// "typedef" "enum" ID "inline" "friend" "extern" StringLiteral "struct"
// "union" "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID"
// "GFUNREAD" "GFARRAYSIZE" LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" "operator" "this" "true"
// "false" OCTALINT LSQUARE TILDE STAR AMPERSAND PLUS MINUS PLUSPLUS MINUSMINUS
// "sizeof" "__alignof__" SCOPE "dynamic_cast" "static_cast" "reinterpret_cast"
// "const_cast" "typeid" DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral
// WStringLiteral FLOATONE FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_134(
    _tokenSet_134_data_, 12);
const unsigned long CPPParser::_tokenSet_135_data_[] = {
    4291835552UL, 4294967295UL, 1677787135UL, 0UL, 524288UL, 16368UL,
    0UL,          0UL,          0UL,          0UL, 0UL,      0UL};
// LESSTHAN "typedef" "enum" ID "inline" "friend" "extern" "struct" "union"
// "class" "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE" LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto"
// "register" "static" "mutable" "_inline" "__inline" "virtual" "explicit"
// "typename" "char" "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t"
// "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64"
// "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64"
// "long" "signed" "unsigned" "float" "double" "void" "_declspec" "__declspec"
// "const" "__const" "volatile" "__volatile__" LSQUARE STAR AMPERSAND SCOPE
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_135(
    _tokenSet_135_data_, 12);
const unsigned long CPPParser::_tokenSet_136_data_[] = {
    4294194912UL, 4294967295UL, 2011365375UL, 4293918720UL,
    4294967295UL, 16399UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// LESSTHAN GREATERTHAN "typedef" "enum" ID "inline" "friend" ASSIGNEQUAL
// "extern" StringLiteral "struct" "union" "class" "_stdcall" "__stdcall"
// "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE" LPAREN RPAREN
// "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE
// TILDE STAR AMPERSAND TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL
// SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL
// QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR
// POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__" SCOPE DOT POINTERTO
// "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid"
// DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE
// FLOATTWO NOT "new" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_136(
    _tokenSet_136_data_, 12);
const unsigned long CPPParser::_tokenSet_137_data_[] = {
    1056UL, 4294959105UL, 4095UL, 0UL, 524288UL, 0UL,
    0UL,    0UL,          0UL,    0UL, 0UL,      0UL};
// LESSTHAN ID LPAREN "char" "wchar_t" "bool" "short" "int" "_int8" "__int8"
// "int8_t" "_int16" "__int16" "int16_t" "_int32" "__int32" "int32_t" "_int64"
// "__int64" "int64_t" "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64"
// "__w64" "long" "signed" "unsigned" "float" "double" "void" "_declspec"
// "__declspec" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_137(
    _tokenSet_137_data_, 12);
const unsigned long CPPParser::_tokenSet_138_data_[] = {
    2098176UL, 1UL, 333447168UL, 0UL, 4161273856UL, 3UL,
    0UL,       0UL, 0UL,         0UL, 0UL,          0UL};
// ID StringLiteral LPAREN "operator" "this" "true" "false" OCTALINT TILDE
// SCOPE DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral
// FLOATONE FLOATTWO
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_138(
    _tokenSet_138_data_, 12);
const unsigned long CPPParser::_tokenSet_139_data_[] = {
    4291835520UL, 4294967293UL, 65535UL, 0UL, 524288UL, 0UL,
    0UL,          0UL,          0UL,     0UL, 0UL,      0UL};
// "typedef" "enum" ID "inline" "friend" "extern" "struct" "union" "class"
// "_stdcall" "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD"
// "GFARRAYSIZE"
// LPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static" "mutable"
// "_inline" "__inline" "virtual" "explicit" "typename" "char" "wchar_t"
// "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" SCOPE
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_139(
    _tokenSet_139_data_, 12);
const unsigned long CPPParser::_tokenSet_140_data_[] = {
    4292753376UL, 4294967295UL, 3959619583UL, 4293918720UL, 557055UL, 16368UL,
    0UL,          0UL,          0UL,          0UL,          0UL,      0UL};
// LESSTHAN GREATERTHAN "typedef" SEMICOLON "enum" ID "inline" "friend"
// RCURLY ASSIGNEQUAL COLON "extern" "struct" "union" "class" "_stdcall"
// "__stdcall" "GFEXCLUDE" "GFINCLUDE" "GFID" "GFUNREAD" "GFARRAYSIZE"
// LPAREN RPAREN "GFARRAYSIZES" "GFARRAYELEMSIZE" "auto" "register" "static"
// "mutable" "_inline" "__inline" "virtual" "explicit" "typename" "char"
// "wchar_t" "bool" "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16"
// "int16_t" "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t"
// "uint8_t" "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed"
// "unsigned" "float" "double" "void" "_declspec" "__declspec" "const"
// "__const" "volatile" "__volatile__" COMMA LSQUARE RSQUARE STAR AMPERSAND
// ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL
// SHIFTRIGHTEQUAL BITWISEANDEQUAL BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK
// OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL LESSTHANOREQUALTO
// GREATERTHANOREQUALTO
// SHIFTLEFT SHIFTRIGHT PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR SCOPE
// "_cdecl" "__cdecl" "_near" "__near" "_far" "__far" "__interrupt" "pascal"
// "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_140(
    _tokenSet_140_data_, 12);
const unsigned long CPPParser::_tokenSet_141_data_[] = {
    917856UL, 3UL, 3959554048UL, 4293918720UL, 3276799UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,       0UL};
// LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON LPAREN RPAREN
// COMMA LSQUARE RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL
// MINUSEQUAL PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR
// NOTEQUAL EQUAL LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT
// PLUS MINUS DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS DOT POINTERTO
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_141(
    _tokenSet_141_data_, 12);
const unsigned long CPPParser::_tokenSet_142_data_[] = {
    100664320UL, 0UL, 1677721600UL, 0UL, 524288UL, 16368UL,
    0UL,         0UL, 0UL,          0UL, 0UL,      0UL};
// ID "_stdcall" "__stdcall" LSQUARE STAR AMPERSAND SCOPE "_cdecl" "__cdecl"
// "_near" "__near" "_far" "__far" "__interrupt" "pascal" "_pascal" "__pascal"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_142(
    _tokenSet_142_data_, 12);
const unsigned long CPPParser::_tokenSet_143_data_[] = {
    103679328UL,  4294963203UL, 4293066751UL, 4293918720UL,
    4291821567UL, 32767UL,      0UL,          0UL,
    0UL,          0UL,          0UL,          0UL};
// LESSTHAN GREATERTHAN SEMICOLON ID RCURLY ASSIGNEQUAL COLON StringLiteral
// "_stdcall" "__stdcall" LPAREN RPAREN "typename" "char" "wchar_t" "bool"
// "short" "int" "_int8" "__int8" "int8_t" "_int16" "__int16" "int16_t"
// "_int32" "__int32" "int32_t" "_int64" "__int64" "int64_t" "uint8_t"
// "uint16_t" "uint32_t" "uint64_t" "_w64" "__w64" "long" "signed" "unsigned"
// "float" "double" "void" "_declspec" "__declspec" "const" "__const" "volatile"
// "__volatile__" COMMA "operator" "this" "true" "false" OCTALINT LSQUARE
// RSQUARE TILDE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR PLUSPLUS MINUSMINUS "sizeof" "__alignof__"
// SCOPE "dynamic_cast" "static_cast" "reinterpret_cast" "const_cast" "typeid"
// DECIMALINT HEXADECIMALINT CharLiteral WCharLiteral WStringLiteral FLOATONE
// FLOATTWO NOT "new" "_cdecl" "__cdecl" "_near" "__near" "_far" "__far"
// "__interrupt" "pascal" "_pascal" "__pascal" "delete"
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_143(
    _tokenSet_143_data_, 12);
const unsigned long CPPParser::_tokenSet_144_data_[] = {
    917856UL, 3UL, 3892445184UL, 4293918720UL, 32767UL, 0UL,
    0UL,      0UL, 0UL,          0UL,          0UL,     0UL};
// LESSTHAN GREATERTHAN SEMICOLON RCURLY ASSIGNEQUAL COLON LPAREN RPAREN
// COMMA RSQUARE STAR AMPERSAND ELLIPSIS TIMESEQUAL DIVIDEEQUAL MINUSEQUAL
// PLUSEQUAL MODEQUAL SHIFTLEFTEQUAL SHIFTRIGHTEQUAL BITWISEANDEQUAL
// BITWISEXOREQUAL
// BITWISEOREQUAL QUESTIONMARK OR AND BITWISEOR BITWISEXOR NOTEQUAL EQUAL
// LESSTHANOREQUALTO GREATERTHANOREQUALTO SHIFTLEFT SHIFTRIGHT PLUS MINUS
// DIVIDE MOD DOTMBR POINTERTOMBR
const ANTLR_USE_NAMESPACE(antlr) BitSet CPPParser::_tokenSet_144(
    _tokenSet_144_data_, 12);