nus-yam/ex-repair huggingface dataset:
Program: 160821
Project: 160821
Buggy source:
public final IdentifierContext identifier() throws RecognitionException {
  IdentifierContext _localctx=new IdentifierContext(_ctx,getState());
  enterRule(_localctx,128,RULE_identifier);
  try {
    int _alt;
    enterOuterAlt(_localctx,1);
{
      setState(583);
      match(ALPHA_NUMERIC);
      setState(588);
      _errHandler.sync(this);
      _alt=getInterpreter().adaptivePredict(_input,63,_ctx);
      while (_alt != 2 && _alt != -1) {
        if (_alt == 1) {
{
{
              setState(584);
              match(15);
              setState(585);
              match(ALPHA_NUMERIC);
            }
          }
        }
        setState(590);
        _errHandler.sync(this);
        _alt=getInterpreter().adaptivePredict(_input,63,_ctx);
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final IdentifierContext identifier() throws RecognitionException {
  IdentifierContext _localctx=new IdentifierContext(_ctx,getState());
  enterRule(_localctx,128,RULE_identifier);
  try {
    int _alt;
    enterOuterAlt(_localctx,1);
{
      setState(596);
      match(ALPHA_NUMERIC);
      setState(601);
      _errHandler.sync(this);
      _alt=getInterpreter().adaptivePredict(_input,64,_ctx);
      while (_alt != 2 && _alt != -1) {
        if (_alt == 1) {
{
{
              setState(597);
              match(15);
              setState(598);
              match(ALPHA_NUMERIC);
            }
          }
        }
        setState(603);
        _errHandler.sync(this);
        _alt=getInterpreter().adaptivePredict(_input,64,_ctx);
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160822
Project: 160822
Buggy source:
public final No_brackets_curlies_or_squaresContext no_brackets_curlies_or_squares() throws RecognitionException {
  No_brackets_curlies_or_squaresContext _localctx=new No_brackets_curlies_or_squaresContext(_ctx,getState());
  enterRule(_localctx,28,RULE_no_brackets_curlies_or_squares);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(230);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 22)| (1L << 28))) != 0) || _la == OPENING_CURLY || _la == CLOSING_CURLY)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final No_brackets_curlies_or_squaresContext no_brackets_curlies_or_squares() throws RecognitionException {
  No_brackets_curlies_or_squaresContext _localctx=new No_brackets_curlies_or_squaresContext(_ctx,getState());
  enterRule(_localctx,28,RULE_no_brackets_curlies_or_squares);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(230);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 23)| (1L << 29))) != 0) || _la == OPENING_CURLY || _la == CLOSING_CURLY)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160823
Project: 160823
Buggy source:
public final Exclusive_or_expressionContext exclusive_or_expression() throws RecognitionException {
  Exclusive_or_expressionContext _localctx=new Exclusive_or_expressionContext(_ctx,getState());
  enterRule(_localctx,60,RULE_exclusive_or_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(284);
      bit_and_expression();
      setState(287);
      _la=_input.LA(1);
      if (_la == 40) {
{
          setState(285);
          match(40);
          setState(286);
          exclusive_or_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Exclusive_or_expressionContext exclusive_or_expression() throws RecognitionException {
  Exclusive_or_expressionContext _localctx=new Exclusive_or_expressionContext(_ctx,getState());
  enterRule(_localctx,60,RULE_exclusive_or_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(284);
      bit_and_expression();
      setState(287);
      _la=_input.LA(1);
      if (_la == 41) {
{
          setState(285);
          match(41);
          setState(286);
          exclusive_or_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160824
Project: 160824
Buggy source:
public final Function_decl_specifiersContext function_decl_specifiers() throws RecognitionException {
  Function_decl_specifiersContext _localctx=new Function_decl_specifiersContext(_ctx,getState());
  enterRule(_localctx,10,RULE_function_decl_specifiers);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(153);
      _la=_input.LA(1);
      if (!(((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (13 - 13)) | (1L << (14 - 13)) | (1L << (36 - 13))| (1L << (38 - 13))| (1L << (VIRTUAL - 13)))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Function_decl_specifiersContext function_decl_specifiers() throws RecognitionException {
  Function_decl_specifiersContext _localctx=new Function_decl_specifiersContext(_ctx,getState());
  enterRule(_localctx,10,RULE_function_decl_specifiers);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(153);
      _la=_input.LA(1);
      if (!(((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (13 - 13)) | (1L << (14 - 13)) | (1L << (37 - 13))| (1L << (39 - 13))| (1L << (VIRTUAL - 13)))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160825
Project: 160825
Buggy source:
public final Var_declContext var_decl() throws RecognitionException {
  Var_declContext _localctx=new Var_declContext(_ctx,getState());
  enterRule(_localctx,98,RULE_var_decl);
  try {
    setState(443);
switch (getInterpreter().adaptivePredict(_input,38,_ctx)) {
case 1:
      _localctx=new DeclByClassContext(_localctx);
    enterOuterAlt(_localctx,1);
{
    setState(436);
    class_def();
    setState(438);
switch (getInterpreter().adaptivePredict(_input,37,_ctx)) {
case 1:
{
        setState(437);
        init_declarator_list();
      }
    break;
}
}
break;
case 2:
_localctx=new DeclByTypeContext(_localctx);
enterOuterAlt(_localctx,2);
{
setState(440);
type_name();
setState(441);
init_declarator_list();
}
break;
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}

Fixed version (ground truth):
public final Var_declContext var_decl() throws RecognitionException {
  Var_declContext _localctx=new Var_declContext(_ctx,getState());
  enterRule(_localctx,98,RULE_var_decl);
  try {
    setState(456);
switch (getInterpreter().adaptivePredict(_input,39,_ctx)) {
case 1:
      _localctx=new DeclByClassContext(_localctx);
    enterOuterAlt(_localctx,1);
{
    setState(449);
    class_def();
    setState(451);
switch (getInterpreter().adaptivePredict(_input,38,_ctx)) {
case 1:
{
        setState(450);
        init_declarator_list();
      }
    break;
}
}
break;
case 2:
_localctx=new DeclByTypeContext(_localctx);
enterOuterAlt(_localctx,2);
{
setState(453);
type_name();
setState(454);
init_declarator_list();
}
break;
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}
Program: 160826
Project: 160826
Buggy source:
public final Base_classContext base_class() throws RecognitionException {
  Base_classContext _localctx=new Base_classContext(_ctx,getState());
  enterRule(_localctx,112,RULE_base_class);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(492);
      _la=_input.LA(1);
      if (_la == VIRTUAL) {
{
          setState(491);
          match(VIRTUAL);
        }
      }
      setState(495);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 25) | (1L << 31) | (1L << 44))) != 0)) {
{
          setState(494);
          access_specifier();
        }
      }
      setState(497);
      identifier();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Base_classContext base_class() throws RecognitionException {
  Base_classContext _localctx=new Base_classContext(_ctx,getState());
  enterRule(_localctx,112,RULE_base_class);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(505);
      _la=_input.LA(1);
      if (_la == VIRTUAL) {
{
          setState(504);
          match(VIRTUAL);
        }
      }
      setState(508);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 26) | (1L << 32) | (1L << 45))) != 0)) {
{
          setState(507);
          access_specifier();
        }
      }
      setState(510);
      identifier();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160827
Project: 160827
Buggy source:
public final No_comma_or_semicolonContext no_comma_or_semicolon() throws RecognitionException {
  No_comma_or_semicolonContext _localctx=new No_comma_or_semicolonContext(_ctx,getState());
  enterRule(_localctx,40,RULE_no_comma_or_semicolon);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(242);
      _la=_input.LA(1);
      if (_la <= 0 || (_la == 26 || _la == 45)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final No_comma_or_semicolonContext no_comma_or_semicolon() throws RecognitionException {
  No_comma_or_semicolonContext _localctx=new No_comma_or_semicolonContext(_ctx,getState());
  enterRule(_localctx,40,RULE_no_comma_or_semicolon);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(242);
      _la=_input.LA(1);
      if (_la <= 0 || (_la == 27 || _la == 46)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160828
Project: 160828
Buggy source:
public final Base_typeContext base_type() throws RecognitionException {
  Base_typeContext _localctx=new Base_typeContext(_ctx,getState());
  enterRule(_localctx,116,RULE_base_type);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(537);
switch (getInterpreter().adaptivePredict(_input,53,_ctx)) {
case 1:
{
          setState(532);
          match(ALPHA_NUMERIC);
        }
      break;
case 2:
{
      setState(533);
      match(VOID);
    }
  break;
case 3:
{
  setState(534);
  match(LONG);
}
break;
case 4:
{
setState(535);
match(LONG);
setState(536);
match(LONG);
}
break;
}
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}

Fixed version (ground truth):
public final Base_typeContext base_type() throws RecognitionException {
  Base_typeContext _localctx=new Base_typeContext(_ctx,getState());
  enterRule(_localctx,116,RULE_base_type);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(550);
switch (getInterpreter().adaptivePredict(_input,54,_ctx)) {
case 1:
{
          setState(545);
          match(ALPHA_NUMERIC);
        }
      break;
case 2:
{
      setState(546);
      match(VOID);
    }
  break;
case 3:
{
  setState(547);
  match(LONG);
}
break;
case 4:
{
setState(548);
match(LONG);
setState(549);
match(LONG);
}
break;
}
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}
Program: 160829
Project: 160829
Buggy source:
public final Shift_expressionContext shift_expression() throws RecognitionException {
  Shift_expressionContext _localctx=new Shift_expressionContext(_ctx,getState());
  enterRule(_localctx,68,RULE_shift_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(306);
      additive_expression();
      setState(309);
      _la=_input.LA(1);
      if (_la == 8 || _la == 39) {
{
          setState(307);
          _la=_input.LA(1);
          if (!(_la == 8 || _la == 39)) {
            _errHandler.recoverInline(this);
          }
          consume();
          setState(308);
          shift_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Shift_expressionContext shift_expression() throws RecognitionException {
  Shift_expressionContext _localctx=new Shift_expressionContext(_ctx,getState());
  enterRule(_localctx,68,RULE_shift_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(306);
      additive_expression();
      setState(309);
      _la=_input.LA(1);
      if (_la == 8 || _la == 40) {
{
          setState(307);
          _la=_input.LA(1);
          if (!(_la == 8 || _la == 40)) {
            _errHandler.recoverInline(this);
          }
          consume();
          setState(308);
          shift_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160830
Project: 160830
Buggy source:
public final Class_nameContext class_name() throws RecognitionException {
  Class_nameContext _localctx=new Class_nameContext(_ctx,getState());
  enterRule(_localctx,108,RULE_class_name);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(480);
      identifier();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Class_nameContext class_name() throws RecognitionException {
  Class_nameContext _localctx=new Class_nameContext(_ctx,getState());
  enterRule(_localctx,108,RULE_class_name);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(493);
      identifier();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160831
Project: 160831
Buggy source:
public final No_brackets_or_semicolonContext no_brackets_or_semicolon() throws RecognitionException {
  No_brackets_or_semicolonContext _localctx=new No_brackets_or_semicolonContext(_ctx,getState());
  enterRule(_localctx,30,RULE_no_brackets_or_semicolon);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(232);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 12) | (1L << 28) | (1L << 45))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final No_brackets_or_semicolonContext no_brackets_or_semicolon() throws RecognitionException {
  No_brackets_or_semicolonContext _localctx=new No_brackets_or_semicolonContext(_ctx,getState());
  enterRule(_localctx,30,RULE_no_brackets_or_semicolon);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(232);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 12) | (1L << 29) | (1L << 46))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160832
Project: 160832
Buggy source:
public final Function_argument_listContext function_argument_list() throws RecognitionException {
  Function_argument_listContext _localctx=new Function_argument_listContext(_ctx,getState());
  enterRule(_localctx,84,RULE_function_argument_list);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(387);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4)| (1L << 20)| (1L << 27)| (1L << 28)| (1L << 37)| (1L << 43)| (1L << 53))) != 0) || ((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & ((1L << (ALPHA_NUMERIC - 83)) | (1L << (HEX_LITERAL - 83)) | (1L << (DECIMAL_LITERAL - 83))| (1L << (OCTAL_LITERAL - 83))| (1L << (FLOATING_POINT_LITERAL - 83))| (1L << (CHAR - 83))| (1L << (STRING - 83)))) != 0)) {
{
          setState(379);
          function_argument();
          setState(384);
          _errHandler.sync(this);
          _la=_input.LA(1);
          while (_la == 26) {
{
{
                setState(380);
                match(26);
                setState(381);
                function_argument();
              }
            }
            setState(386);
            _errHandler.sync(this);
            _la=_input.LA(1);
          }
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Function_argument_listContext function_argument_list() throws RecognitionException {
  Function_argument_listContext _localctx=new Function_argument_listContext(_ctx,getState());
  enterRule(_localctx,84,RULE_function_argument_list);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(400);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4)| (1L << 20)| (1L << 21)| (1L << 28)| (1L << 29)| (1L << 38)| (1L << 44)| (1L << 54))) != 0) || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (ALPHA_NUMERIC - 84)) | (1L << (HEX_LITERAL - 84)) | (1L << (DECIMAL_LITERAL - 84))| (1L << (OCTAL_LITERAL - 84))| (1L << (FLOATING_POINT_LITERAL - 84))| (1L << (CHAR - 84))| (1L << (STRING - 84)))) != 0)) {
{
          setState(392);
          function_argument();
          setState(397);
          _errHandler.sync(this);
          _la=_input.LA(1);
          while (_la == 27) {
{
{
                setState(393);
                match(27);
                setState(394);
                function_argument();
              }
            }
            setState(399);
            _errHandler.sync(this);
            _la=_input.LA(1);
          }
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160833
Project: 160833
Buggy source:
public final Simple_declContext simple_decl() throws RecognitionException {
  Simple_declContext _localctx=new Simple_declContext(_ctx,getState());
  enterRule(_localctx,96,RULE_simple_decl);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
{
        setState(429);
        _la=_input.LA(1);
        if (_la == TYPEDEF) {
{
            setState(428);
            match(TYPEDEF);
          }
        }
        setState(432);
        _la=_input.LA(1);
        if (_la == TEMPLATE) {
{
            setState(431);
            template_decl_start();
          }
        }
      }
      setState(434);
      var_decl();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Simple_declContext simple_decl() throws RecognitionException {
  Simple_declContext _localctx=new Simple_declContext(_ctx,getState());
  enterRule(_localctx,96,RULE_simple_decl);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
{
        setState(442);
        _la=_input.LA(1);
        if (_la == TYPEDEF) {
{
            setState(441);
            match(TYPEDEF);
          }
        }
        setState(445);
        _la=_input.LA(1);
        if (_la == TEMPLATE) {
{
            setState(444);
            template_decl_start();
          }
        }
      }
      setState(447);
      var_decl();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160834
Project: 160834
Buggy source:
public final PtrsContext ptrs() throws RecognitionException {
  PtrsContext _localctx=new PtrsContext(_ctx,getState());
  enterRule(_localctx,132,RULE_ptrs);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(594);
      _errHandler.sync(this);
      _la=_input.LA(1);
      do {
{
{
            setState(593);
            ptr_operator();
          }
        }
        setState(596);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
 while (_la == 1 || _la == 2);
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final PtrsContext ptrs() throws RecognitionException {
  PtrsContext _localctx=new PtrsContext(_ctx,getState());
  enterRule(_localctx,132,RULE_ptrs);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(607);
      _errHandler.sync(this);
      _la=_input.LA(1);
      do {
{
{
            setState(606);
            ptr_operator();
          }
        }
        setState(609);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
 while (_la == 1 || _la == 2);
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160835
Project: 160835
Buggy source:
public final Relational_expressionContext relational_expression() throws RecognitionException {
  Relational_expressionContext _localctx=new Relational_expressionContext(_ctx,getState());
  enterRule(_localctx,66,RULE_relational_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(300);
      shift_expression();
      setState(304);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 5) | (1L << 7) | (1L << 48)| (1L << 54))) != 0)) {
{
          setState(301);
          relational_operator();
          setState(302);
          relational_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Relational_expressionContext relational_expression() throws RecognitionException {
  Relational_expressionContext _localctx=new Relational_expressionContext(_ctx,getState());
  enterRule(_localctx,66,RULE_relational_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(300);
      shift_expression();
      setState(304);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 5) | (1L << 7) | (1L << 49)| (1L << 55))) != 0)) {
{
          setState(301);
          relational_operator();
          setState(302);
          relational_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160836
Project: 160836
Buggy source:
public final Unary_expressionContext unary_expression() throws RecognitionException {
  Unary_expressionContext _localctx=new Unary_expressionContext(_ctx,getState());
  enterRule(_localctx,78,RULE_unary_expression);
  try {
    setState(343);
switch (_input.LA(1)) {
case 4:
case 37:
      enterOuterAlt(_localctx,1);
{
      setState(336);
      inc_dec();
      setState(337);
      cast_expression();
    }
  break;
case 1:
case 2:
case 20:
case 27:
case 43:
case 53:
enterOuterAlt(_localctx,2);
{
setState(339);
unary_operator();
setState(340);
cast_expression();
}
break;
case 28:
case ALPHA_NUMERIC:
case HEX_LITERAL:
case DECIMAL_LITERAL:
case OCTAL_LITERAL:
case FLOATING_POINT_LITERAL:
case CHAR:
case STRING:
enterOuterAlt(_localctx,3);
{
setState(342);
postfix_expression(0);
}
break;
default :
throw new NoViableAltException(this);
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}

Fixed version (ground truth):
public final Unary_expressionContext unary_expression() throws RecognitionException {
  Unary_expressionContext _localctx=new Unary_expressionContext(_ctx,getState());
  enterRule(_localctx,78,RULE_unary_expression);
  int _la;
  try {
    setState(356);
switch (getInterpreter().adaptivePredict(_input,22,_ctx)) {
case 1:
      enterOuterAlt(_localctx,1);
{
      setState(336);
      inc_dec();
      setState(337);
      cast_expression();
    }
  break;
case 2:
enterOuterAlt(_localctx,2);
{
setState(339);
unary_operator();
setState(340);
cast_expression();
}
break;
case 3:
enterOuterAlt(_localctx,3);
{
setState(342);
match(21);
setState(343);
match(29);
setState(344);
type_name();
setState(348);
_errHandler.sync(this);
_la=_input.LA(1);
while (_la == 1 || _la == 2) {
{
{
setState(345);
ptr_operator();
}
}
setState(350);
_errHandler.sync(this);
_la=_input.LA(1);
}
setState(351);
match(12);
}
break;
case 4:
enterOuterAlt(_localctx,4);
{
setState(353);
match(21);
setState(354);
unary_expression();
}
break;
case 5:
enterOuterAlt(_localctx,5);
{
setState(355);
postfix_expression(0);
}
break;
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}
Program: 160838
Project: 160838
Buggy source:
public final And_expressionContext and_expression() throws RecognitionException {
  And_expressionContext _localctx=new And_expressionContext(_ctx,getState());
  enterRule(_localctx,56,RULE_and_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(274);
      inclusive_or_expression();
      setState(277);
      _la=_input.LA(1);
      if (_la == 46) {
{
          setState(275);
          match(46);
          setState(276);
          and_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final And_expressionContext and_expression() throws RecognitionException {
  And_expressionContext _localctx=new And_expressionContext(_ctx,getState());
  enterRule(_localctx,56,RULE_and_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(274);
      inclusive_or_expression();
      setState(277);
      _la=_input.LA(1);
      if (_la == 47) {
{
          setState(275);
          match(47);
          setState(276);
          and_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160839
Project: 160839
Buggy source:
public final Additive_expressionContext additive_expression() throws RecognitionException {
  Additive_expressionContext _localctx=new Additive_expressionContext(_ctx,getState());
  enterRule(_localctx,70,RULE_additive_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(311);
      multiplicative_expression();
      setState(314);
      _la=_input.LA(1);
      if (_la == 27 || _la == 43) {
{
          setState(312);
          _la=_input.LA(1);
          if (!(_la == 27 || _la == 43)) {
            _errHandler.recoverInline(this);
          }
          consume();
          setState(313);
          additive_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Additive_expressionContext additive_expression() throws RecognitionException {
  Additive_expressionContext _localctx=new Additive_expressionContext(_ctx,getState());
  enterRule(_localctx,70,RULE_additive_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(311);
      multiplicative_expression();
      setState(314);
      _la=_input.LA(1);
      if (_la == 28 || _la == 44) {
{
          setState(312);
          _la=_input.LA(1);
          if (!(_la == 28 || _la == 44)) {
            _errHandler.recoverInline(this);
          }
          consume();
          setState(313);
          additive_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160840
Project: 160840
Buggy source:
public final Multiplicative_expressionContext multiplicative_expression() throws RecognitionException {
  Multiplicative_expressionContext _localctx=new Multiplicative_expressionContext(_ctx,getState());
  enterRule(_localctx,72,RULE_multiplicative_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(316);
      cast_expression();
      setState(319);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 2) | (1L << 10) | (1L << 52))) != 0)) {
{
          setState(317);
          _la=_input.LA(1);
          if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 2) | (1L << 10) | (1L << 52))) != 0))) {
            _errHandler.recoverInline(this);
          }
          consume();
          setState(318);
          multiplicative_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Multiplicative_expressionContext multiplicative_expression() throws RecognitionException {
  Multiplicative_expressionContext _localctx=new Multiplicative_expressionContext(_ctx,getState());
  enterRule(_localctx,72,RULE_multiplicative_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(316);
      cast_expression();
      setState(319);
      _la=_input.LA(1);
      if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 2) | (1L << 10) | (1L << 53))) != 0)) {
{
          setState(317);
          _la=_input.LA(1);
          if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 2) | (1L << 10) | (1L << 53))) != 0))) {
            _errHandler.recoverInline(this);
          }
          consume();
          setState(318);
          multiplicative_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160841
Project: 160841
Buggy source:
public final No_angle_brackets_or_bracketsContext no_angle_brackets_or_brackets() throws RecognitionException {
  No_angle_brackets_or_bracketsContext _localctx=new No_angle_brackets_or_bracketsContext(_ctx,getState());
  enterRule(_localctx,32,RULE_no_angle_brackets_or_brackets);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(234);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 5) | (1L << 12) | (1L << 28)| (1L << 48))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final No_angle_brackets_or_bracketsContext no_angle_brackets_or_brackets() throws RecognitionException {
  No_angle_brackets_or_bracketsContext _localctx=new No_angle_brackets_or_bracketsContext(_ctx,getState());
  enterRule(_localctx,32,RULE_no_angle_brackets_or_brackets);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(234);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 5) | (1L << 12) | (1L << 29)| (1L << 49))) != 0))) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160842
Project: 160842
Buggy source:
public final Param_type_idContext param_type_id() throws RecognitionException {
  Param_type_idContext _localctx=new Param_type_idContext(_ctx,getState());
  enterRule(_localctx,126,RULE_param_type_id);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(569);
      _la=_input.LA(1);
      if (_la == 1 || _la == 2) {
{
          setState(568);
          ptrs();
        }
      }
      setState(578);
switch (getInterpreter().adaptivePredict(_input,61,_ctx)) {
case 1:
{
          setState(571);
          match(28);
          setState(572);
          param_type_id();
          setState(573);
          match(12);
        }
      break;
case 2:
{
      setState(576);
      _la=_input.LA(1);
      if (((((_la - 25)) & ~0x3f) == 0 && ((1L << (_la - 25)) & ((1L << (25 - 25)) | (1L << (31 - 25)) | (1L << (44 - 25))| (1L << (ALPHA_NUMERIC - 25)))) != 0)) {
{
          setState(575);
          parameter_name();
        }
      }
    }
  break;
}
setState(581);
_la=_input.LA(1);
if (_la == 3 || _la == 28) {
{
  setState(580);
  type_suffix();
}
}
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}

Fixed version (ground truth):
public final Param_type_idContext param_type_id() throws RecognitionException {
  Param_type_idContext _localctx=new Param_type_idContext(_ctx,getState());
  enterRule(_localctx,126,RULE_param_type_id);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(582);
      _la=_input.LA(1);
      if (_la == 1 || _la == 2) {
{
          setState(581);
          ptrs();
        }
      }
      setState(591);
switch (getInterpreter().adaptivePredict(_input,62,_ctx)) {
case 1:
{
          setState(584);
          match(29);
          setState(585);
          param_type_id();
          setState(586);
          match(12);
        }
      break;
case 2:
{
      setState(589);
      _la=_input.LA(1);
      if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (26 - 26)) | (1L << (32 - 26)) | (1L << (45 - 26))| (1L << (ALPHA_NUMERIC - 26)))) != 0)) {
{
          setState(588);
          parameter_name();
        }
      }
    }
  break;
}
setState(594);
_la=_input.LA(1);
if (_la == 3 || _la == 29) {
{
  setState(593);
  type_suffix();
}
}
}
}
 catch (RecognitionException re) {
_localctx.exception=re;
_errHandler.reportError(this,re);
_errHandler.recover(this,re);
}
 finally {
exitRule();
}
return _localctx;
}
Program: 160843
Project: 160843
Buggy source:
public final Assign_water_l2Context assign_water_l2() throws RecognitionException {
  Assign_water_l2Context _localctx=new Assign_water_l2Context(_ctx,getState());
  enterRule(_localctx,44,RULE_assign_water_l2);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(246);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 22)| (1L << 28))) != 0) || _la == OPENING_CURLY || _la == CLOSING_CURLY)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Assign_water_l2Context assign_water_l2() throws RecognitionException {
  Assign_water_l2Context _localctx=new Assign_water_l2Context(_ctx,getState());
  enterRule(_localctx,44,RULE_assign_water_l2);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(246);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 23)| (1L << 29))) != 0) || _la == OPENING_CURLY || _la == CLOSING_CURLY)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160844
Project: 160844
Buggy source:
public final Base_classesContext base_classes() throws RecognitionException {
  Base_classesContext _localctx=new Base_classesContext(_ctx,getState());
  enterRule(_localctx,110,RULE_base_classes);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(482);
      match(29);
      setState(483);
      base_class();
      setState(488);
      _errHandler.sync(this);
      _la=_input.LA(1);
      while (_la == 26) {
{
{
            setState(484);
            match(26);
            setState(485);
            base_class();
          }
        }
        setState(490);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Base_classesContext base_classes() throws RecognitionException {
  Base_classesContext _localctx=new Base_classesContext(_ctx,getState());
  enterRule(_localctx,110,RULE_base_classes);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(495);
      match(30);
      setState(496);
      base_class();
      setState(501);
      _errHandler.sync(this);
      _la=_input.LA(1);
      while (_la == 27) {
{
{
            setState(497);
            match(27);
            setState(498);
            base_class();
          }
        }
        setState(503);
        _errHandler.sync(this);
        _la=_input.LA(1);
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160845
Project: 160845
Buggy source:
public final Param_typeContext param_type() throws RecognitionException {
  Param_typeContext _localctx=new Param_typeContext(_ctx,getState());
  enterRule(_localctx,124,RULE_param_type);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(565);
      param_decl_specifiers();
      setState(566);
      param_type_id();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Param_typeContext param_type() throws RecognitionException {
  Param_typeContext _localctx=new Param_typeContext(_ctx,getState());
  enterRule(_localctx,124,RULE_param_type);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(578);
      param_decl_specifiers();
      setState(579);
      param_type_id();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160846
Project: 160846
Buggy source:
public final Or_expressionContext or_expression() throws RecognitionException {
  Or_expressionContext _localctx=new Or_expressionContext(_ctx,getState());
  enterRule(_localctx,54,RULE_or_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(269);
      and_expression();
      setState(272);
      _la=_input.LA(1);
      if (_la == 47) {
{
          setState(270);
          match(47);
          setState(271);
          or_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Or_expressionContext or_expression() throws RecognitionException {
  Or_expressionContext _localctx=new Or_expressionContext(_ctx,getState());
  enterRule(_localctx,54,RULE_or_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(269);
      and_expression();
      setState(272);
      _la=_input.LA(1);
      if (_la == 48) {
{
          setState(270);
          match(48);
          setState(271);
          or_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160847
Project: 160847
Buggy source:
public final Function_argumentContext function_argument() throws RecognitionException {
  Function_argumentContext _localctx=new Function_argumentContext(_ctx,getState());
  enterRule(_localctx,86,RULE_function_argument);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(389);
      assign_expr();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Function_argumentContext function_argument() throws RecognitionException {
  Function_argumentContext _localctx=new Function_argumentContext(_ctx,getState());
  enterRule(_localctx,86,RULE_function_argument);
  try {
    enterOuterAlt(_localctx,1);
{
      setState(402);
      assign_expr();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160848
Project: 160848
Buggy source:
public final Assign_waterContext assign_water() throws RecognitionException {
  Assign_waterContext _localctx=new Assign_waterContext(_ctx,getState());
  enterRule(_localctx,42,RULE_assign_water);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(244);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 22)| (1L << 26)| (1L << 28)| (1L << 45))) != 0) || _la == OPENING_CURLY || _la == CLOSING_CURLY)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Assign_waterContext assign_water() throws RecognitionException {
  Assign_waterContext _localctx=new Assign_waterContext(_ctx,getState());
  enterRule(_localctx,42,RULE_assign_water);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(244);
      _la=_input.LA(1);
      if (_la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 23)| (1L << 27)| (1L << 29)| (1L << 46))) != 0) || _la == OPENING_CURLY || _la == CLOSING_CURLY)) {
        _errHandler.recoverInline(this);
      }
      consume();
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}
Program: 160849
Project: 160849
Buggy source:
public final Equality_expressionContext equality_expression() throws RecognitionException {
  Equality_expressionContext _localctx=new Equality_expressionContext(_ctx,getState());
  enterRule(_localctx,64,RULE_equality_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(294);
      relational_expression();
      setState(298);
      _la=_input.LA(1);
      if (_la == 6 || _la == 51) {
{
          setState(295);
          equality_operator();
          setState(296);
          equality_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}

Fixed version (ground truth):
public final Equality_expressionContext equality_expression() throws RecognitionException {
  Equality_expressionContext _localctx=new Equality_expressionContext(_ctx,getState());
  enterRule(_localctx,64,RULE_equality_expression);
  int _la;
  try {
    enterOuterAlt(_localctx,1);
{
      setState(294);
      relational_expression();
      setState(298);
      _la=_input.LA(1);
      if (_la == 6 || _la == 52) {
{
          setState(295);
          equality_operator();
          setState(296);
          equality_expression();
        }
      }
    }
  }
 catch (  RecognitionException re) {
    _localctx.exception=re;
    _errHandler.reportError(this,re);
    _errHandler.recover(this,re);
  }
 finally {
    exitRule();
  }
  return _localctx;
}