nus-yam/ex-repair huggingface dataset:
Program: 35829
Project: 35829
Buggy source:
/** 
 * Returns a   {@code Constructor} object that reflects the specifiedpublic constructor of the class represented by this  {@code Class}object. The   {@code parameterTypes} parameter is an array of{@code Class} objects that identify the constructor's formalparameter types, in declared order. If this  {@code Class} object represents an inner classdeclared in a non-static context, the formal parameter types include the explicit enclosing instance as the first parameter. <p> The constructor to reflect is the public constructor of the class represented by this  {@code Class} object whose formal parametertypes match those specified by  {@code parameterTypes}.
 * @param parameterTypes the parameter array
 * @return the {@code Constructor} object of the public constructor thatmatches the specified  {@code parameterTypes}
 * @throws NoSuchMethodException if a matching method is not found.
 * @throws SecurityException If a security manager, <i>s</i>, is present and the caller's class loader is not the same as or an ancestor of the class loader for the current class and invocation of  {@link SecurityManager#checkPackageAccess s.checkPackageAccess()} denies access to the packageof this class.
 * @since 1.1
 */
@CallerSensitive public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException {
  checkMemberAccess(Member.PUBLIC,Reflection.getCallerClass(),true);
  return getConstructor0(parameterTypes,Member.PUBLIC);
}

Fixed version (ground truth):
/** 
 * Returns a   {@code Constructor} object that reflects the specifiedpublic constructor of the class represented by this  {@code Class}object. The   {@code parameterTypes} parameter is an array of{@code Class} objects that identify the constructor's formalparameter types, in declared order. If this  {@code Class} object represents an inner classdeclared in a non-static context, the formal parameter types include the explicit enclosing instance as the first parameter. <p> The constructor to reflect is the public constructor of the class represented by this  {@code Class} object whose formal parametertypes match those specified by  {@code parameterTypes}.
 * @param parameterTypes the parameter array
 * @return the {@code Constructor} object of the public constructor thatmatches the specified  {@code parameterTypes}
 * @throws NoSuchMethodException if a matching method is not found.
 * @throws SecurityException If a security manager, <i>s</i>, is present and the caller's class loader is not the same as or an ancestor of the class loader for the current class and invocation of  {@link SecurityManager#checkPackageAccess s.checkPackageAccess()} denies access to the packageof this class.
 * @since 1.1
 */
@CallerSensitive public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException {
  checkMemberAccess(Member.PUBLIC,Reflection.getCallerClass(),true);
  return getReflectionFactory().copyConstructor(getConstructor0(parameterTypes,Member.PUBLIC));
}
Program: 35830
Project: 35830
Buggy source:
private Method getMethod0(String name,Class<?>[] parameterTypes,boolean includeStaticMethods){
  MethodArray interfaceCandidates=new MethodArray(2);
  Method res=privateGetMethodRecursive(name,parameterTypes,includeStaticMethods,interfaceCandidates);
  if (res != null)   return res;
  interfaceCandidates.removeLessSpecifics();
  return interfaceCandidates.getFirst();
}

Fixed version (ground truth):
private Method getMethod0(String name,Class<?>[] parameterTypes){
  PublicMethods.MethodList res=getMethodsRecursive(name,parameterTypes == null ? EMPTY_CLASS_ARRAY : parameterTypes,true);
  return res == null ? null : res.getMostSpecific();
}
Program: 35831
Project: 35831
Buggy source:
public static void main(String[] args){
  Class[] l1={D1.class};
  test(A1.class.getMethods(),new ArrayList(Arrays.asList(l1)));
  Class[] l2={A2.class};
  test(A2.class.getMethods(),new ArrayList(Arrays.asList(l2)));
  Class[] l3={B3.class,C3.class};
  test(A3.class.getMethods(),new ArrayList(Arrays.asList(l3)));
  Class[] l4={B4.class,D4.class};
  test(A4.class.getMethods(),new ArrayList(Arrays.asList(l4)));
}

Fixed version (ground truth):
public static void main(String[] args){
  Class[] l1={D1.class};
  test(A1.class.getMethods(),new ArrayList(Arrays.asList(l1)));
  Class[] l2={A2.class};
  test(A2.class.getMethods(),new ArrayList(Arrays.asList(l2)));
  Class[] l3={B3.class,C3.class};
  test(A3.class.getMethods(),new ArrayList(Arrays.asList(l3)));
  Class[] l4={B4.class};
  test(A4.class.getMethods(),new ArrayList(Arrays.asList(l4)));
}
Program: 35832
Project: 35832
Buggy source:
void setContentBounds(WindowDimensions dims){
  XToolkit.awtLock();
  try {
    Rectangle newBounds=dims.getBounds();
    Insets in=dims.getInsets();
    if (in != null) {
      newBounds.setLocation(-in.left,-in.top);
    }
    if (insLog.isLoggable(PlatformLogger.Level.FINE)) {
      insLog.fine("String_Node_Str",newBounds,getBounds());
    }
    boolean needHandleResize=!(newBounds.equals(getBounds()));
    reshape(newBounds);
    if (needHandleResize) {
      insLog.fine("String_Node_Str");
      handleResize(newBounds);
    }
  }
  finally {
    XToolkit.awtUnlock();
  }
  validateSurface();
}

Fixed version (ground truth):
void setContentBounds(WindowDimensions dims){
  XToolkit.awtLock();
  try {
    Rectangle newBounds=dims.getBounds();
    Insets in=dims.getInsets();
    if (in != null) {
      newBounds.setLocation(-in.left,-in.top);
    }
    if (insLog.isLoggable(PlatformLogger.Level.FINE)) {
      insLog.fine("String_Node_Str",newBounds,getBounds());
    }
    boolean needHandleResize=!(newBounds.equals(getBounds()));
    boolean needPaint=width <= 0 || height <= 0;
    reshape(newBounds);
    if (needHandleResize) {
      insLog.fine("String_Node_Str");
      handleResize(newBounds);
    }
    if (needPaint) {
      postPaintEvent(target,0,0,newBounds.width,newBounds.height);
    }
  }
  finally {
    XToolkit.awtUnlock();
  }
}
Program: 35833
Project: 35833
Buggy source:
void setContentBounds(WindowDimensions dims){
  XToolkit.awtLock();
  try {
    Rectangle newBounds=dims.getBounds();
    Insets in=dims.getInsets();
    if (in != null) {
      newBounds.setLocation(-in.left,-in.top);
    }
    if (insLog.isLoggable(PlatformLogger.Level.FINE)) {
      insLog.fine("String_Node_Str",newBounds,getBounds());
    }
    boolean needHandleResize=!(newBounds.equals(getBounds()));
    reshape(newBounds);
    if (needHandleResize) {
      insLog.fine("String_Node_Str");
      handleResize(newBounds);
    }
  }
  finally {
    XToolkit.awtUnlock();
  }
  validateSurface();
}

Fixed version (ground truth):
void setContentBounds(WindowDimensions dims){
  XToolkit.awtLock();
  try {
    Rectangle newBounds=dims.getBounds();
    Insets in=dims.getInsets();
    if (in != null) {
      newBounds.setLocation(-in.left,-in.top);
    }
    if (insLog.isLoggable(PlatformLogger.Level.FINE)) {
      insLog.fine("String_Node_Str",newBounds,getBounds());
    }
    boolean needHandleResize=!(newBounds.equals(getBounds()));
    boolean needPaint=width <= 0 || height <= 0;
    reshape(newBounds);
    if (needHandleResize) {
      insLog.fine("String_Node_Str");
      handleResize(newBounds);
    }
    if (needPaint) {
      postPaintEvent(target,0,0,newBounds.width,newBounds.height);
    }
  }
  finally {
    XToolkit.awtUnlock();
  }
}
Program: 35834
Project: 35834
Buggy source:
CaInfo scan(String s){
  try {
    Scanner scanner=scannerFactory.newScanner(s,false);
    Matched in=new Matched(scanner);
    Parser parser=new Parser(in,proc,s);
    Completeness stat=parser.parseUnit();
    int endPos=stat == Completeness.UNKNOWN ? s.length() : in.prevCT.endPos;
    return new CaInfo(stat,endPos);
  }
 catch (  SyntaxException ex) {
    return new CaInfo(error(),s.length());
  }
}

Fixed version (ground truth):
CaInfo scan(String s){
  try {
    Parser parser=new Parser(() -> new Matched(scannerFactory.newScanner(s,false)),() -> proc.taskFactory.new ParseTask(s));
    Completeness stat=parser.parseUnit();
    int endPos=stat == Completeness.UNKNOWN ? s.length() : parser.endPos();
    return new CaInfo(stat,endPos);
  }
 catch (  SyntaxException ex) {
    return new CaInfo(error(),s.length());
  }
}
Program: 35835
Project: 35835
Buggy source:
/** 
 * @return the next scanner token
 */
private CT nextCT(){
  TK prevTK=currentCT.kind;
  while (true) {
    db("String_Node_Str");
    CT ct;
switch (current.kind) {
case EOF:
      db("String_Node_Str");
    if (stack.isEmpty()) {
      ct=new CT(EOF,current);
    }
 else {
      TokenKind unmatched=stack.pop().kind;
      stack.clear();
      ct=new CT(UNMATCHED,current,"String_Node_Str" + unmatched);
    }
  break;
case LPAREN:
case LBRACE:
case LBRACKET:
stack.push(advance());
prevTK=SEMI;
continue;
case RPAREN:
ct=match(PARENS,TokenKind.LPAREN);
break;
case RBRACE:
ct=match(BRACES,TokenKind.LBRACE);
break;
case RBRACKET:
ct=match(BRACKETS,TokenKind.LBRACKET);
break;
default :
ct=new CT(TK.tokenKindToTK(current.kind),advance());
break;
}
if (ct.kind.isStart() && !prevTK.isOkToTerminate()) {
return new CT(ERROR,current,"String_Node_Str" + prevTK + "String_Node_Str"+ ct.kind+ "String_Node_Str");
}
if (stack.isEmpty() || ct.kind.isError()) {
return ct;
}
prevTK=ct.kind;
}
}

Fixed version (ground truth):
/** 
 * @return the next scanner token
 */
private CT nextCT(){
  TK prevTK=currentCT.kind;
  while (true) {
    db("String_Node_Str");
    CT ct;
switch (current.kind) {
case EOF:
      db("String_Node_Str");
    if (stack.isEmpty()) {
      ct=new CT(EOF,current);
    }
 else {
      TokenKind unmatched=stack.pop().kind;
      stack.clear();
      ct=new CT(UNMATCHED,current,"String_Node_Str" + unmatched);
    }
  break;
case LPAREN:
case LBRACE:
case LBRACKET:
stack.push(advance());
prevTK=SEMI;
continue;
case RPAREN:
ct=match(PARENS,TokenKind.LPAREN);
break;
case RBRACE:
ct=match(BRACES,TokenKind.LBRACE);
break;
case RBRACKET:
ct=match(BRACKETS,TokenKind.LBRACKET);
break;
default :
ct=new CT(TK.tokenKindToTK(prevTK,current.kind),advance());
break;
}
if (ct.kind.isStart() && !prevTK.isOkToTerminate()) {
return new CT(ERROR,current,"String_Node_Str" + prevTK + "String_Node_Str"+ ct.kind+ "String_Node_Str");
}
if (stack.isEmpty() || ct.kind.isError()) {
return ct;
}
prevTK=ct.kind;
}
}
Program: 35836
Project: 35836
Buggy source:
private static TK tokenKindToTK(TokenKind kind){
  TK tk=tokenKindToTKMap.get(kind);
  if (tk == null) {
    System.err.printf("String_Node_Str",TK.class.getCanonicalName(),TokenKind.class.getCanonicalName(),kind);
    throw new InternalError("String_Node_Str" + kind);
  }
  return tk;
}

Fixed version (ground truth):
private static TK tokenKindToTK(TK prev,TokenKind kind){
  TK tk=tokenKindToTKMap.get(kind);
  if (tk == null) {
    System.err.printf("String_Node_Str",TK.class.getCanonicalName(),TokenKind.class.getCanonicalName(),kind);
    throw new InternalError("String_Node_Str" + kind);
  }
  return tk.mapping != null ? tk.mapping.apply(prev) : tk;
}
Program: 35837
Project: 35837
Buggy source:
public Completeness disambiguateDeclarationVsExpression(){
  ParseTask pt=proc.taskFactory.new ParseTask(scannedInput);
  List<? extends Tree> units=pt.units();
  if (units.isEmpty()) {
    return error();
  }
  Tree unitTree=units.get(0);
switch (unitTree.getKind()) {
case EXPRESSION_STATEMENT:
    return parseExpressionOptionalSemi();
case LABELED_STATEMENT:
  if (shouldAbort(IDENTIFIER))   return checkResult;
if (shouldAbort(COLON)) return checkResult;
return parseStatement();
case VARIABLE:
case IMPORT:
case CLASS:
case ENUM:
case ANNOTATION_TYPE:
case INTERFACE:
case METHOD:
return parseDeclaration();
default :
return error();
}
}

Fixed version (ground truth):
public Completeness disambiguateDeclarationVsExpression(){
  ParseTask pt=parseFactory.get();
  List<? extends Tree> units=pt.units();
  if (units.isEmpty()) {
    return error();
  }
  Tree unitTree=units.get(0);
switch (unitTree.getKind()) {
case EXPRESSION_STATEMENT:
    return parseExpressionOptionalSemi();
case LABELED_STATEMENT:
  if (shouldAbort(IDENTIFIER))   return checkResult;
if (shouldAbort(COLON)) return checkResult;
return parseStatement();
case VARIABLE:
case IMPORT:
case CLASS:
case ENUM:
case ANNOTATION_TYPE:
case INTERFACE:
case METHOD:
return parseDeclaration();
default :
return error();
}
}
Program: 35838
Project: 35838
Buggy source:
public Completeness parseDeclaration(){
  boolean isImport=token.kind == IMPORT;
  while (token.kind.isDeclaration()) {
    nextToken();
  }
switch (token.kind) {
case EQ:
    nextToken();
  if (token.kind == BRACES) {
    nextToken();
    return lastly(SEMI);
  }
return parseExpressionStatement();
case BRACES:
case SEMI:
nextToken();
return Completeness.COMPLETE;
case UNMATCHED:
nextToken();
return Completeness.DEFINITELY_INCOMPLETE;
case EOF:
switch (in.prevCT.kind) {
case BRACES:
case SEMI:
return Completeness.COMPLETE;
case IDENTIFIER:
case BRACKETS:
return Completeness.COMPLETE_WITH_SEMI;
case STAR:
if (isImport) {
return Completeness.COMPLETE_WITH_SEMI;
}
 else {
return Completeness.DEFINITELY_INCOMPLETE;
}
default :
return Completeness.DEFINITELY_INCOMPLETE;
}
default :
return error();
}
}

Fixed version (ground truth):
public Completeness parseDeclaration(){
  boolean isImport=token.kind == IMPORT;
  while (token.kind.isDeclaration()) {
    nextToken();
  }
switch (token.kind) {
case EQ:
    nextToken();
  if (token.kind == BRACES) {
    nextToken();
    return lastly(SEMI);
  }
return parseExpressionStatement();
case BRACES:
case SEMI:
nextToken();
return Completeness.COMPLETE;
case UNMATCHED:
nextToken();
return Completeness.DEFINITELY_INCOMPLETE;
case EOF:
switch (in.prevCT.kind) {
case BRACES:
case SEMI:
return Completeness.COMPLETE;
case IDENTIFIER:
case BRACKETS:
return Completeness.COMPLETE_WITH_SEMI;
case DOTSTAR:
if (isImport) {
return Completeness.COMPLETE_WITH_SEMI;
}
 else {
return Completeness.UNKNOWN;
}
default :
return Completeness.DEFINITELY_INCOMPLETE;
}
default :
return error();
}
}
Program: 35839
Project: 35839
Buggy source:
Parser(Matched in,JShell proc,String scannedInput){
  this.in=in;
  nextToken();
  this.proc=proc;
  this.scannedInput=scannedInput;
}

Fixed version (ground truth):
Parser(Supplier<Matched> matchedFactory,Supplier<ParseTask> parseFactory){
  this.matchedFactory=matchedFactory;
  this.parseFactory=parseFactory;
  resetInput();
}
Program: 35840
Project: 35840
Buggy source:
void TK(TokenKind tokenKind,int b){
  this.tokenKind=tokenKind;
  this.belongs=b;
}

Fixed version (ground truth):
void TK(TokenKind tokenKind,int b){
  this.tokenKind=tokenKind;
  this.belongs=b;
  this.mapping=null;
}
Program: 35841
Project: 35841
Buggy source:
CaInfo scan(String s){
  try {
    Scanner scanner=scannerFactory.newScanner(s,false);
    Matched in=new Matched(scanner);
    Parser parser=new Parser(in,proc,s);
    Completeness stat=parser.parseUnit();
    int endPos=stat == Completeness.UNKNOWN ? s.length() : in.prevCT.endPos;
    return new CaInfo(stat,endPos);
  }
 catch (  SyntaxException ex) {
    return new CaInfo(error(),s.length());
  }
}

Fixed version (ground truth):
CaInfo scan(String s){
  try {
    Parser parser=new Parser(() -> new Matched(scannerFactory.newScanner(s,false)),() -> proc.taskFactory.new ParseTask(s));
    Completeness stat=parser.parseUnit();
    int endPos=stat == Completeness.UNKNOWN ? s.length() : parser.endPos();
    return new CaInfo(stat,endPos);
  }
 catch (  SyntaxException ex) {
    return new CaInfo(error(),s.length());
  }
}
Program: 35842
Project: 35842
Buggy source:
/** 
 * @return the next scanner token
 */
private CT nextCT(){
  TK prevTK=currentCT.kind;
  while (true) {
    db("String_Node_Str");
    CT ct;
switch (current.kind) {
case EOF:
      db("String_Node_Str");
    if (stack.isEmpty()) {
      ct=new CT(EOF,current);
    }
 else {
      TokenKind unmatched=stack.pop().kind;
      stack.clear();
      ct=new CT(UNMATCHED,current,"String_Node_Str" + unmatched);
    }
  break;
case LPAREN:
case LBRACE:
case LBRACKET:
stack.push(advance());
prevTK=SEMI;
continue;
case RPAREN:
ct=match(PARENS,TokenKind.LPAREN);
break;
case RBRACE:
ct=match(BRACES,TokenKind.LBRACE);
break;
case RBRACKET:
ct=match(BRACKETS,TokenKind.LBRACKET);
break;
default :
ct=new CT(TK.tokenKindToTK(current.kind),advance());
break;
}
if (ct.kind.isStart() && !prevTK.isOkToTerminate()) {
return new CT(ERROR,current,"String_Node_Str" + prevTK + "String_Node_Str"+ ct.kind+ "String_Node_Str");
}
if (stack.isEmpty() || ct.kind.isError()) {
return ct;
}
prevTK=ct.kind;
}
}

Fixed version (ground truth):
/** 
 * @return the next scanner token
 */
private CT nextCT(){
  TK prevTK=currentCT.kind;
  while (true) {
    db("String_Node_Str");
    CT ct;
switch (current.kind) {
case EOF:
      db("String_Node_Str");
    if (stack.isEmpty()) {
      ct=new CT(EOF,current);
    }
 else {
      TokenKind unmatched=stack.pop().kind;
      stack.clear();
      ct=new CT(UNMATCHED,current,"String_Node_Str" + unmatched);
    }
  break;
case LPAREN:
case LBRACE:
case LBRACKET:
stack.push(advance());
prevTK=SEMI;
continue;
case RPAREN:
ct=match(PARENS,TokenKind.LPAREN);
break;
case RBRACE:
ct=match(BRACES,TokenKind.LBRACE);
break;
case RBRACKET:
ct=match(BRACKETS,TokenKind.LBRACKET);
break;
default :
ct=new CT(TK.tokenKindToTK(prevTK,current.kind),advance());
break;
}
if (ct.kind.isStart() && !prevTK.isOkToTerminate()) {
return new CT(ERROR,current,"String_Node_Str" + prevTK + "String_Node_Str"+ ct.kind+ "String_Node_Str");
}
if (stack.isEmpty() || ct.kind.isError()) {
return ct;
}
prevTK=ct.kind;
}
}
Program: 35843
Project: 35843
Buggy source:
private static TK tokenKindToTK(TokenKind kind){
  TK tk=tokenKindToTKMap.get(kind);
  if (tk == null) {
    System.err.printf("String_Node_Str",TK.class.getCanonicalName(),TokenKind.class.getCanonicalName(),kind);
    throw new InternalError("String_Node_Str" + kind);
  }
  return tk;
}

Fixed version (ground truth):
private static TK tokenKindToTK(TK prev,TokenKind kind){
  TK tk=tokenKindToTKMap.get(kind);
  if (tk == null) {
    System.err.printf("String_Node_Str",TK.class.getCanonicalName(),TokenKind.class.getCanonicalName(),kind);
    throw new InternalError("String_Node_Str" + kind);
  }
  return tk.mapping != null ? tk.mapping.apply(prev) : tk;
}
Program: 35844
Project: 35844
Buggy source:
public Completeness disambiguateDeclarationVsExpression(){
  ParseTask pt=proc.taskFactory.new ParseTask(scannedInput);
  List<? extends Tree> units=pt.units();
  if (units.isEmpty()) {
    return error();
  }
  Tree unitTree=units.get(0);
switch (unitTree.getKind()) {
case EXPRESSION_STATEMENT:
    return parseExpressionOptionalSemi();
case LABELED_STATEMENT:
  if (shouldAbort(IDENTIFIER))   return checkResult;
if (shouldAbort(COLON)) return checkResult;
return parseStatement();
case VARIABLE:
case IMPORT:
case CLASS:
case ENUM:
case ANNOTATION_TYPE:
case INTERFACE:
case METHOD:
return parseDeclaration();
default :
return error();
}
}

Fixed version (ground truth):
public Completeness disambiguateDeclarationVsExpression(){
  ParseTask pt=parseFactory.get();
  List<? extends Tree> units=pt.units();
  if (units.isEmpty()) {
    return error();
  }
  Tree unitTree=units.get(0);
switch (unitTree.getKind()) {
case EXPRESSION_STATEMENT:
    return parseExpressionOptionalSemi();
case LABELED_STATEMENT:
  if (shouldAbort(IDENTIFIER))   return checkResult;
if (shouldAbort(COLON)) return checkResult;
return parseStatement();
case VARIABLE:
case IMPORT:
case CLASS:
case ENUM:
case ANNOTATION_TYPE:
case INTERFACE:
case METHOD:
return parseDeclaration();
default :
return error();
}
}
Program: 35845
Project: 35845
Buggy source:
public Completeness parseDeclaration(){
  boolean isImport=token.kind == IMPORT;
  while (token.kind.isDeclaration()) {
    nextToken();
  }
switch (token.kind) {
case EQ:
    nextToken();
  if (token.kind == BRACES) {
    nextToken();
    return lastly(SEMI);
  }
return parseExpressionStatement();
case BRACES:
case SEMI:
nextToken();
return Completeness.COMPLETE;
case UNMATCHED:
nextToken();
return Completeness.DEFINITELY_INCOMPLETE;
case EOF:
switch (in.prevCT.kind) {
case BRACES:
case SEMI:
return Completeness.COMPLETE;
case IDENTIFIER:
case BRACKETS:
return Completeness.COMPLETE_WITH_SEMI;
case STAR:
if (isImport) {
return Completeness.COMPLETE_WITH_SEMI;
}
 else {
return Completeness.DEFINITELY_INCOMPLETE;
}
default :
return Completeness.DEFINITELY_INCOMPLETE;
}
default :
return error();
}
}

Fixed version (ground truth):
public Completeness parseDeclaration(){
  boolean isImport=token.kind == IMPORT;
  while (token.kind.isDeclaration()) {
    nextToken();
  }
switch (token.kind) {
case EQ:
    nextToken();
  if (token.kind == BRACES) {
    nextToken();
    return lastly(SEMI);
  }
return parseExpressionStatement();
case BRACES:
case SEMI:
nextToken();
return Completeness.COMPLETE;
case UNMATCHED:
nextToken();
return Completeness.DEFINITELY_INCOMPLETE;
case EOF:
switch (in.prevCT.kind) {
case BRACES:
case SEMI:
return Completeness.COMPLETE;
case IDENTIFIER:
case BRACKETS:
return Completeness.COMPLETE_WITH_SEMI;
case DOTSTAR:
if (isImport) {
return Completeness.COMPLETE_WITH_SEMI;
}
 else {
return Completeness.UNKNOWN;
}
default :
return Completeness.DEFINITELY_INCOMPLETE;
}
default :
return error();
}
}
Program: 35846
Project: 35846
Buggy source:
Parser(Matched in,JShell proc,String scannedInput){
  this.in=in;
  nextToken();
  this.proc=proc;
  this.scannedInput=scannedInput;
}

Fixed version (ground truth):
Parser(Supplier<Matched> matchedFactory,Supplier<ParseTask> parseFactory){
  this.matchedFactory=matchedFactory;
  this.parseFactory=parseFactory;
  resetInput();
}
Program: 35847
Project: 35847
Buggy source:
void TK(TokenKind tokenKind,int b){
  this.tokenKind=tokenKind;
  this.belongs=b;
}

Fixed version (ground truth):
void TK(TokenKind tokenKind,int b){
  this.tokenKind=tokenKind;
  this.belongs=b;
  this.mapping=null;
}
Program: 35848
Project: 35848
Buggy source:
/** 
 * Utility routine to check if the InetAddress in a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return holder().getAddress() == 0;
}

Fixed version (ground truth):
/** 
 * Utility routine to check if the InetAddress is a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return holder().getAddress() == 0;
}
Program: 35849
Project: 35849
Buggy source:
/** 
 * Utility routine to check if the InetAddress in a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return false;
}

Fixed version (ground truth):
/** 
 * Utility routine to check if the InetAddress is a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return false;
}
Program: 35851
Project: 35851
Buggy source:
/** 
 * Returns an output stream for this socket. <p> If this socket has an associated channel then the resulting output stream delegates all of its operations to the channel.  If the channel is in non-blocking mode then the output stream's   {@code write}operations will throw an   {@link java.nio.channels.IllegalBlockingModeException}. <p> Closing the returned   {@link java.io.OutputStream OutputStream}will close the associated socket.
 * @return     an output stream for writing bytes to this socket.
 * @exception IOException  if an I/O error occurs when creating theoutput stream or if the socket is not connected.
 * @revised 1.4
 * @spec JSR-51
 */
public OutputStream getOutputStream() throws IOException {
  if (isClosed())   throw new SocketException("String_Node_Str");
  if (!isConnected())   throw new SocketException("String_Node_Str");
  if (isOutputShutdown())   throw new SocketException("String_Node_Str");
  final Socket s=this;
  OutputStream os=null;
  try {
    os=AccessController.doPrivileged(new PrivilegedExceptionAction<>(){
      public OutputStream run() throws IOException {
        return impl.getOutputStream();
      }
    }
);
  }
 catch (  java.security.PrivilegedActionException e) {
    throw (IOException)e.getException();
  }
  return os;
}

Fixed version (ground truth):
/** 
 * Returns an output stream for this socket. <p> If this socket has an associated channel then the resulting output stream delegates all of its operations to the channel.  If the channel is in non-blocking mode then the output stream's   {@code write}operations will throw an   {@link java.nio.channels.IllegalBlockingModeException}. <p> Closing the returned   {@link java.io.OutputStream OutputStream}will close the associated socket.
 * @return     an output stream for writing bytes to this socket.
 * @exception IOException  if an I/O error occurs when creating theoutput stream or if the socket is not connected.
 * @revised 1.4
 * @spec JSR-51
 */
public OutputStream getOutputStream() throws IOException {
  if (isClosed())   throw new SocketException("String_Node_Str");
  if (!isConnected())   throw new SocketException("String_Node_Str");
  if (isOutputShutdown())   throw new SocketException("String_Node_Str");
  OutputStream os=null;
  try {
    os=AccessController.doPrivileged(new PrivilegedExceptionAction<>(){
      public OutputStream run() throws IOException {
        return impl.getOutputStream();
      }
    }
);
  }
 catch (  java.security.PrivilegedActionException e) {
    throw (IOException)e.getException();
  }
  return os;
}
Program: 35852
Project: 35852
Buggy source:
/** 
 * Utility routine to check if the InetAddress in a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return holder().getAddress() == 0;
}

Fixed version (ground truth):
/** 
 * Utility routine to check if the InetAddress is a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return holder().getAddress() == 0;
}
Program: 35853
Project: 35853
Buggy source:
/** 
 * Utility routine to check if the InetAddress in a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
@Override public boolean isAnyLocalAddress(){
  return holder6.isAnyLocalAddress();
}

Fixed version (ground truth):
/** 
 * Utility routine to check if the InetAddress is a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
@Override public boolean isAnyLocalAddress(){
  return holder6.isAnyLocalAddress();
}
Program: 35854
Project: 35854
Buggy source:
/** 
 * Utility routine to check if the InetAddress in a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return false;
}

Fixed version (ground truth):
/** 
 * Utility routine to check if the InetAddress is a wildcard address.
 * @return a {@code boolean} indicating if the Inetaddress isa wildcard address.
 * @since 1.4
 */
public boolean isAnyLocalAddress(){
  return false;
}
Program: 35856
Project: 35856
Buggy source:
/** 
 * Returns an output stream for this socket. <p> If this socket has an associated channel then the resulting output stream delegates all of its operations to the channel.  If the channel is in non-blocking mode then the output stream's   {@code write}operations will throw an   {@link java.nio.channels.IllegalBlockingModeException}. <p> Closing the returned   {@link java.io.OutputStream OutputStream}will close the associated socket.
 * @return     an output stream for writing bytes to this socket.
 * @exception IOException  if an I/O error occurs when creating theoutput stream or if the socket is not connected.
 * @revised 1.4
 * @spec JSR-51
 */
public OutputStream getOutputStream() throws IOException {
  if (isClosed())   throw new SocketException("String_Node_Str");
  if (!isConnected())   throw new SocketException("String_Node_Str");
  if (isOutputShutdown())   throw new SocketException("String_Node_Str");
  final Socket s=this;
  OutputStream os=null;
  try {
    os=AccessController.doPrivileged(new PrivilegedExceptionAction<>(){
      public OutputStream run() throws IOException {
        return impl.getOutputStream();
      }
    }
);
  }
 catch (  java.security.PrivilegedActionException e) {
    throw (IOException)e.getException();
  }
  return os;
}

Fixed version (ground truth):
/** 
 * Returns an output stream for this socket. <p> If this socket has an associated channel then the resulting output stream delegates all of its operations to the channel.  If the channel is in non-blocking mode then the output stream's   {@code write}operations will throw an   {@link java.nio.channels.IllegalBlockingModeException}. <p> Closing the returned   {@link java.io.OutputStream OutputStream}will close the associated socket.
 * @return     an output stream for writing bytes to this socket.
 * @exception IOException  if an I/O error occurs when creating theoutput stream or if the socket is not connected.
 * @revised 1.4
 * @spec JSR-51
 */
public OutputStream getOutputStream() throws IOException {
  if (isClosed())   throw new SocketException("String_Node_Str");
  if (!isConnected())   throw new SocketException("String_Node_Str");
  if (isOutputShutdown())   throw new SocketException("String_Node_Str");
  OutputStream os=null;
  try {
    os=AccessController.doPrivileged(new PrivilegedExceptionAction<>(){
      public OutputStream run() throws IOException {
        return impl.getOutputStream();
      }
    }
);
  }
 catch (  java.security.PrivilegedActionException e) {
    throw (IOException)e.getException();
  }
  return os;
}
Program: 35857
Project: 35857
Buggy source:
/** 
 * extract the root name from a versioned entry name given inode for META-INF/versions/9/foo/bar.class and prefix META-INF/versions/9/ returns foo/bar.class
 */
private byte[] getRootName(IndexNode prefix,IndexNode inode){
  int offset=prefix.name.length;
  byte[] fullName=inode.name;
  return Arrays.copyOfRange(fullName,offset,fullName.length);
}

Fixed version (ground truth):
/** 
 * extract the root name from a versioned entry name given inode for META-INF/versions/9/foo/bar.class and prefix META-INF/versions/9/ returns foo/bar.class
 */
private byte[] getRootName(IndexNode prefix,IndexNode inode){
  int offset=prefix.name.length - 1;
  byte[] fullName=inode.name;
  return Arrays.copyOfRange(fullName,offset,fullName.length);
}
Program: 35858
Project: 35858
Buggy source:
public int method(){
  return e.method;
}

Fixed version (ground truth):
public int method();
Program: 35859
Project: 35859
Buggy source:
public long compressedSize(){
  return e.csize;
}

Fixed version (ground truth):
public long compressedSize();
Program: 35860
Project: 35860
Buggy source:
public long crc(){
  return e.crc;
}

Fixed version (ground truth):
public long crc();
Program: 35861
Project: 35861
Buggy source:
public byte[] extra(){
  if (e.extra != null)   return Arrays.copyOf(e.extra,e.extra.length);
  return null;
}

Fixed version (ground truth):
public byte[] extra();
Program: 35862
Project: 35862
Buggy source:
public byte[] comment(){
  if (e.comment != null)   return Arrays.copyOf(e.comment,e.comment.length);
  return null;
}

Fixed version (ground truth):
public byte[] comment();
Program: 35863
Project: 35863
Buggy source:
public String toString(){
  StringBuilder sb=new StringBuilder(1024);
  Formatter fm=new Formatter(sb);
  if (creationTime() != null)   fm.format("String_Node_Str",creationTime().toMillis());
 else   fm.format("String_Node_Str");
  if (lastAccessTime() != null)   fm.format("String_Node_Str",lastAccessTime().toMillis());
 else   fm.format("String_Node_Str");
  fm.format("String_Node_Str",lastModifiedTime().toMillis());
  fm.format("String_Node_Str",isRegularFile());
  fm.format("String_Node_Str",isDirectory());
  fm.format("String_Node_Str",isSymbolicLink());
  fm.format("String_Node_Str",isOther());
  fm.format("String_Node_Str",fileKey());
  fm.format("String_Node_Str",size());
  fm.format("String_Node_Str",compressedSize());
  fm.format("String_Node_Str",crc());
  fm.format("String_Node_Str",method());
  fm.close();
  return sb.toString();
}

Fixed version (ground truth):
public String toString();
Program: 35864
Project: 35864
Buggy source:
/** 
 * extract the root name from a versioned entry name given inode for META-INF/versions/9/foo/bar.class and prefix META-INF/versions/9/ returns foo/bar.class
 */
private byte[] getRootName(IndexNode prefix,IndexNode inode){
  int offset=prefix.name.length;
  byte[] fullName=inode.name;
  return Arrays.copyOfRange(fullName,offset,fullName.length);
}

Fixed version (ground truth):
/** 
 * extract the root name from a versioned entry name given inode for META-INF/versions/9/foo/bar.class and prefix META-INF/versions/9/ returns foo/bar.class
 */
private byte[] getRootName(IndexNode prefix,IndexNode inode){
  int offset=prefix.name.length - 1;
  byte[] fullName=inode.name;
  return Arrays.copyOfRange(fullName,offset,fullName.length);
}
Program: 35865
Project: 35865
Buggy source:
public int method(){
  return e.method;
}

Fixed version (ground truth):
public int method();
Program: 35866
Project: 35866
Buggy source:
public long compressedSize(){
  return e.csize;
}

Fixed version (ground truth):
public long compressedSize();
Program: 35867
Project: 35867
Buggy source:
public long crc(){
  return e.crc;
}

Fixed version (ground truth):
public long crc();
Program: 35868
Project: 35868
Buggy source:
public byte[] extra(){
  if (e.extra != null)   return Arrays.copyOf(e.extra,e.extra.length);
  return null;
}

Fixed version (ground truth):
public byte[] extra();
Program: 35869
Project: 35869
Buggy source:
public byte[] comment(){
  if (e.comment != null)   return Arrays.copyOf(e.comment,e.comment.length);
  return null;
}

Fixed version (ground truth):
public byte[] comment();
Program: 35870
Project: 35870
Buggy source:
public String toString(){
  StringBuilder sb=new StringBuilder(1024);
  Formatter fm=new Formatter(sb);
  if (creationTime() != null)   fm.format("String_Node_Str",creationTime().toMillis());
 else   fm.format("String_Node_Str");
  if (lastAccessTime() != null)   fm.format("String_Node_Str",lastAccessTime().toMillis());
 else   fm.format("String_Node_Str");
  fm.format("String_Node_Str",lastModifiedTime().toMillis());
  fm.format("String_Node_Str",isRegularFile());
  fm.format("String_Node_Str",isDirectory());
  fm.format("String_Node_Str",isSymbolicLink());
  fm.format("String_Node_Str",isOther());
  fm.format("String_Node_Str",fileKey());
  fm.format("String_Node_Str",size());
  fm.format("String_Node_Str",compressedSize());
  fm.format("String_Node_Str",crc());
  fm.format("String_Node_Str",method());
  fm.close();
  return sb.toString();
}

Fixed version (ground truth):
public String toString();
Program: 35871
Project: 35871
Buggy source:
/** 
 * Constructs an instance with the given file descriptor.
 */
PlainSocketImpl(FileDescriptor fd){
  if (useDualStackImpl) {
    impl=new DualStackPlainSocketImpl(fd,exclusiveBind);
  }
 else {
    impl=new TwoStacksPlainSocketImpl(fd,exclusiveBind);
  }
}

Fixed version (ground truth):
/** 
 * Constructs an instance with the given file descriptor.
 */
PlainSocketImpl(FileDescriptor fd){
  if (!preferIPv4Stack) {
    impl=new DualStackPlainSocketImpl(fd,exclusiveBind);
  }
 else {
    impl=new TwoStacksPlainSocketImpl(fd,exclusiveBind);
  }
}
Program: 35872
Project: 35872
Buggy source:
@Override <V extends Number,A>Future<V> implRead(boolean isScatteringRead,ByteBuffer dst,ByteBuffer[] dsts,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (isScatteringRead) {
    bufs=dsts;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=dst;
  }
  final ReadTask<V,A> readTask=new ReadTask<V,A>(bufs,isScatteringRead,result);
  result.setContext(readTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        readTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  if (Iocp.supportsThreadAgnosticIo()) {
    readTask.run();
  }
 else {
    Invoker.invokeOnThreadInThreadPool(this,readTask);
  }
  return result;
}

Fixed version (ground truth):
@Override <V extends Number,A>Future<V> implRead(boolean isScatteringRead,ByteBuffer dst,ByteBuffer[] dsts,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (isScatteringRead) {
    bufs=dsts;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=dst;
  }
  final ReadTask<V,A> readTask=new ReadTask<V,A>(bufs,isScatteringRead,result);
  result.setContext(readTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        readTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  readTask.run();
  return result;
}
Program: 35873
Project: 35873
Buggy source:
@Override <V extends Number,A>Future<V> implWrite(boolean gatheringWrite,ByteBuffer src,ByteBuffer[] srcs,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (gatheringWrite) {
    bufs=srcs;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=src;
  }
  final WriteTask<V,A> writeTask=new WriteTask<V,A>(bufs,gatheringWrite,result);
  result.setContext(writeTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        writeTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  if (Iocp.supportsThreadAgnosticIo()) {
    writeTask.run();
  }
 else {
    Invoker.invokeOnThreadInThreadPool(this,writeTask);
  }
  return result;
}

Fixed version (ground truth):
@Override <V extends Number,A>Future<V> implWrite(boolean gatheringWrite,ByteBuffer src,ByteBuffer[] srcs,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (gatheringWrite) {
    bufs=srcs;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=src;
  }
  final WriteTask<V,A> writeTask=new WriteTask<V,A>(bufs,gatheringWrite,result);
  result.setContext(writeTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        writeTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  writeTask.run();
  return result;
}
Program: 35874
Project: 35874
Buggy source:
/** 
 * Constructs an instance with the given file descriptor.
 */
PlainSocketImpl(FileDescriptor fd){
  if (useDualStackImpl) {
    impl=new DualStackPlainSocketImpl(fd,exclusiveBind);
  }
 else {
    impl=new TwoStacksPlainSocketImpl(fd,exclusiveBind);
  }
}

Fixed version (ground truth):
/** 
 * Constructs an instance with the given file descriptor.
 */
PlainSocketImpl(FileDescriptor fd){
  if (!preferIPv4Stack) {
    impl=new DualStackPlainSocketImpl(fd,exclusiveBind);
  }
 else {
    impl=new TwoStacksPlainSocketImpl(fd,exclusiveBind);
  }
}
Program: 35875
Project: 35875
Buggy source:
@Override <V extends Number,A>Future<V> implRead(boolean isScatteringRead,ByteBuffer dst,ByteBuffer[] dsts,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (isScatteringRead) {
    bufs=dsts;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=dst;
  }
  final ReadTask<V,A> readTask=new ReadTask<V,A>(bufs,isScatteringRead,result);
  result.setContext(readTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        readTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  if (Iocp.supportsThreadAgnosticIo()) {
    readTask.run();
  }
 else {
    Invoker.invokeOnThreadInThreadPool(this,readTask);
  }
  return result;
}

Fixed version (ground truth):
@Override <V extends Number,A>Future<V> implRead(boolean isScatteringRead,ByteBuffer dst,ByteBuffer[] dsts,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (isScatteringRead) {
    bufs=dsts;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=dst;
  }
  final ReadTask<V,A> readTask=new ReadTask<V,A>(bufs,isScatteringRead,result);
  result.setContext(readTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        readTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  readTask.run();
  return result;
}
Program: 35876
Project: 35876
Buggy source:
@Override <V extends Number,A>Future<V> implWrite(boolean gatheringWrite,ByteBuffer src,ByteBuffer[] srcs,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (gatheringWrite) {
    bufs=srcs;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=src;
  }
  final WriteTask<V,A> writeTask=new WriteTask<V,A>(bufs,gatheringWrite,result);
  result.setContext(writeTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        writeTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  if (Iocp.supportsThreadAgnosticIo()) {
    writeTask.run();
  }
 else {
    Invoker.invokeOnThreadInThreadPool(this,writeTask);
  }
  return result;
}

Fixed version (ground truth):
@Override <V extends Number,A>Future<V> implWrite(boolean gatheringWrite,ByteBuffer src,ByteBuffer[] srcs,long timeout,TimeUnit unit,A attachment,CompletionHandler<V,? super A> handler){
  PendingFuture<V,A> result=new PendingFuture<V,A>(this,handler,attachment);
  ByteBuffer[] bufs;
  if (gatheringWrite) {
    bufs=srcs;
  }
 else {
    bufs=new ByteBuffer[1];
    bufs[0]=src;
  }
  final WriteTask<V,A> writeTask=new WriteTask<V,A>(bufs,gatheringWrite,result);
  result.setContext(writeTask);
  if (timeout > 0L) {
    Future<?> timeoutTask=iocp.schedule(new Runnable(){
      public void run(){
        writeTask.timeout();
      }
    }
,timeout,unit);
    result.setTimeoutTask(timeoutTask);
  }
  writeTask.run();
  return result;
}
Program: 35877
Project: 35877
Buggy source:
@Override public Type add(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IADD);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type add(final MethodVisitor method,final int programPoint){
  return Type.INT.add(method,programPoint);
}
Program: 35878
Project: 35878
Buggy source:
@Override public Type add(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IADD);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type add(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IADD);
  }
 else {
    ldc(method,programPoint);
    JSType.ADD_EXACT.invoke(method);
  }
  return INT;
}
Program: 35879
Project: 35879
Buggy source:
@Override public Type sub(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(ISUB);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type sub(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(ISUB);
  }
 else {
    ldc(method,programPoint);
    JSType.SUB_EXACT.invoke(method);
  }
  return INT;
}
Program: 35880
Project: 35880
Buggy source:
@Override public Type mul(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IMUL);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type mul(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IMUL);
  }
 else {
    ldc(method,programPoint);
    JSType.MUL_EXACT.invoke(method);
  }
  return INT;
}
Program: 35881
Project: 35881
Buggy source:
@Override public Type div(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    JSType.DIV_ZERO.invoke(method);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type div(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    JSType.DIV_ZERO.invoke(method);
  }
 else {
    ldc(method,programPoint);
    JSType.DIV_EXACT.invoke(method);
  }
  return INT;
}
Program: 35882
Project: 35882
Buggy source:
@Override public Type neg(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(INEG);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type neg(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(INEG);
  }
 else {
    ldc(method,programPoint);
    JSType.NEGATE_EXACT.invoke(method);
  }
  return INT;
}
Program: 35883
Project: 35883
Buggy source:
@Override public Type rem(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    JSType.REM_ZERO.invoke(method);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type rem(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    JSType.REM_ZERO.invoke(method);
  }
 else {
    ldc(method,programPoint);
    JSType.REM_EXACT.invoke(method);
  }
  return INT;
}
Program: 35884
Project: 35884
Buggy source:
@Override public Type add(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(LADD);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return LONG;
}

Fixed version (ground truth):
@Override public Type add(final MethodVisitor method,final int programPoint){
  throw new UnsupportedOperationException("String_Node_Str");
}
Program: 35885
Project: 35885
Buggy source:
@Override public Type add(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IADD);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type add(final MethodVisitor method,final int programPoint){
  return Type.INT.add(method,programPoint);
}
Program: 35886
Project: 35886
Buggy source:
@Override public Type add(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IADD);
  }
 else {
    method.visitInvokeDynamicInsn("String_Node_Str","String_Node_Str",MATHBOOTSTRAP,programPoint);
  }
  return INT;
}

Fixed version (ground truth):
@Override public Type add(final MethodVisitor method,final int programPoint){
  if (programPoint == INVALID_PROGRAM_POINT) {
    method.visitInsn(IADD);
  }
 else {
    ldc(method,programPoint);
    JSType.ADD_EXACT.invoke(method);
  }
  return INT;
}