nus-yam/ex-repair huggingface dataset:
Program: 85040
Project: 85040
Buggy source:
@Override public void addResolveError(MarkerList markers){
  Marker marker;
  if (this.arguments.isEmpty()) {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
 else {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
  marker.addInfo("String_Node_Str" + this.name.qualified);
  if (this.instance != null) {
    marker.addInfo("String_Node_Str" + this.instance.getType());
  }
  StringBuilder builder=new StringBuilder("String_Node_Str");
  Util.typesToString("String_Node_Str",this.arguments,"String_Node_Str",builder);
  marker.addInfo(builder.append('}').toString());
}

Fixed version (ground truth):
@Override public void addResolveError(MarkerList markers){
  Marker marker;
  if (this.arguments.isEmpty()) {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
 else {
    marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  }
  marker.addInfo("String_Node_Str" + this.name.qualified);
  if (this.instance != null) {
    marker.addInfo("String_Node_Str" + this.instance.getType());
  }
  StringBuilder builder=new StringBuilder("String_Node_Str");
  Util.typesToString("String_Node_Str",this.arguments,"String_Node_Str",builder);
  marker.addInfo(builder.toString());
}
Program: 85041
Project: 85041
Buggy source:
@Override public boolean addRawAnnotation(String type){
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.SEALED;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.DEPRECATED;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.FUNCTIONAL;
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.SEALED;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.STRICT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.FUNCTIONAL;
return false;
}
return true;
}
Program: 85042
Project: 85042
Buggy source:
@Override public boolean addRawAnnotation(String type){
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.LAZY;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.SEALED;
    return false;
  }
  if ("String_Node_Str".equals(type)) {
    this.modifiers|=Modifiers.DEPRECATED;
    return false;
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.LAZY;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.TRANSIENT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.VOLATILE;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
}
return true;
}
Program: 85043
Project: 85043
Buggy source:
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.INLINE;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.INFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.PREFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.OVERRIDE;
return false;
}
return true;
}

Fixed version (ground truth):
@Override public boolean addRawAnnotation(String type){
switch (type) {
case "String_Node_Str":
    this.modifiers|=Modifiers.INLINE;
  return false;
case "String_Node_Str":
this.modifiers|=Modifiers.INFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.PREFIX;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.SEALED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.NATIVE;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.STRICT;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.DEPRECATED;
return false;
case "String_Node_Str":
this.modifiers|=Modifiers.OVERRIDE;
return false;
}
return true;
}
Program: 85046
Project: 85046
Buggy source:
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeInvIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && instance.isPrimitive()) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeInvIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}
Program: 85047
Project: 85047
Buggy source:
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && instance.isPrimitive()) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,dest,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}
Program: 85048
Project: 85048
Buggy source:
@Override public void writeCall(MethodWriter writer,IValue instance,IArguments arguments,IType type){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && instance.isPrimitive()) {
    this.writeIntrinsic(writer,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  if (type == Types.VOID) {
    if (this.type != Types.VOID) {
      writer.writeInsn(Opcodes.POP);
    }
    return;
  }
  if (type != null) {
    if (type != this.type && !type.isSuperTypeOf(this.type)) {
      writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    }
  }
}

Fixed version (ground truth):
@Override public void writeCall(MethodWriter writer,IValue instance,IArguments arguments,IType type){
  if ((this.modifiers & Modifiers.STATIC) != 0) {
    if (instance != null && instance.getValueType() == IValue.CLASS_ACCESS) {
      instance=null;
    }
    if (this.intrinsicOpcodes != null) {
      this.writeIntrinsic(writer,instance,arguments);
      return;
    }
  }
 else   if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() < INLINE_TRESHOLD) {
  }
  this.writeInvoke(writer,instance,arguments);
  if (type == Types.VOID) {
    if (this.type != Types.VOID) {
      writer.writeInsn(Opcodes.POP);
    }
    return;
  }
  if (type != null) {
    if (type != this.type && !type.isSuperTypeOf(this.type)) {
      writer.writeTypeInsn(Opcodes.CHECKCAST,this.type.getInternalName());
    }
  }
}
Program: 85050
Project: 85050
Buggy source:
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
switch (type) {
case Tokens.STRING_START:
case Tokens.STRING_PART:
    this.value.addString(token.stringValue());
  pm.pushParser(new ExpressionParser(this));
return;
case Tokens.STRING_END:
this.value.addString(token.stringValue());
pm.popParser();
return;
}
throw new SyntaxError(token,"String_Node_Str");
}

Fixed version (ground truth):
@Override public void parse(IParserManager pm,IToken token) throws SyntaxError {
  int type=token.type();
switch (type) {
case Tokens.STRING_START:
case Tokens.STRING_PART:
{
      int nextType=token.next().type();
      if (nextType == Tokens.STRING_PART || nextType == Tokens.STRING_END) {
        throw new SyntaxError(token.next(),"String_Node_Str");
      }
      this.value.addString(token.stringValue());
      pm.pushParser(new ExpressionParser(this));
      return;
    }
case Tokens.STRING_END:
  this.value.addString(token.stringValue());
pm.popParser();
return;
}
throw new SyntaxError(token,"String_Node_Str");
}
Program: 85051
Project: 85051
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.forStart);
  if (this.type != 0) {
    this.variable.type.toString(prefix,buffer);
    buffer.append(' ').append(this.variable.name).append(Formatting.Statements.forEachSeperator);
    this.variable.value.toString(prefix,buffer);
  }
 else {
    if (this.variable != null) {
      this.variable.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.condition != null) {
      buffer.append(' ');
      this.condition.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.update != null) {
      buffer.append(' ');
      this.update.toString(prefix,buffer);
    }
  }
  buffer.append(Formatting.Statements.forEnd);
  if (this.then != null) {
    if (this.then.isStatement()) {
      buffer.append('\n').append(prefix);
      this.then.toString(prefix,buffer);
    }
 else {
      buffer.append(' ');
      this.then.toString(prefix,buffer);
    }
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.forStart);
  if (this.type != 0) {
    this.variable.type.toString(prefix,buffer);
    buffer.append(' ').append(this.variable.name).append(Formatting.Statements.forEachSeperator);
    this.variable.value.toString(prefix,buffer);
  }
 else {
    if (this.variable != null) {
      this.variable.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.condition != null) {
      buffer.append(' ');
      this.condition.toString(prefix,buffer);
    }
    buffer.append(';');
    if (this.update != null) {
      buffer.append(' ');
      this.update.toString(prefix,buffer);
    }
  }
  buffer.append(Formatting.Statements.forEnd);
  if (this.then != null) {
    this.then.toString(prefix,buffer);
  }
}
Program: 85052
Project: 85052
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.valueCount == 0) {
    buffer.append(Formatting.Expression.emptyExpression);
  }
 else {
    buffer.append('\n').append(prefix).append('{').append('\n');
    String prefix1=prefix + Formatting.Method.indent;
    IValue prev=null;
    for (int i=0; i < this.valueCount; i++) {
      IValue value=this.values[i];
      buffer.append(prefix1);
      if (prev != null) {
        ICodePosition pos=value.getPosition();
        if (pos != null && pos.endLine() - prev.getPosition().startLine() > 0) {
          buffer.append('\n').append(prefix1);
        }
      }
      if (this.labels != null) {
        Label l=this.labels[i];
        if (l != null) {
          buffer.append(l.name).append(Formatting.Expression.labelSeperator);
        }
      }
      value.toString(prefix1,buffer);
      buffer.append("String_Node_Str");
      prev=value;
    }
    buffer.append(prefix).append('}');
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.valueCount == 0) {
    buffer.append(Formatting.Expression.emptyExpression);
  }
 else {
    buffer.append('\n').append(prefix).append('{').append('\n');
    String prefix1=prefix + Formatting.Method.indent;
    IValue prev=null;
    for (int i=0; i < this.valueCount; i++) {
      IValue value=this.values[i];
      buffer.append(prefix1);
      if (prev != null) {
        ICodePosition pos=value.getPosition();
        if (pos != null && pos.endLine() - prev.getPosition().startLine() > 1) {
          buffer.append('\n').append(prefix1);
        }
      }
      if (this.labels != null) {
        Label l=this.labels[i];
        if (l != null) {
          buffer.append(l.name).append(Formatting.Expression.labelSeperator);
        }
      }
      value.toString(prefix1,buffer);
      buffer.append("String_Node_Str");
      prev=value;
    }
    buffer.append(prefix).append('}');
  }
}
Program: 85053
Project: 85053
Buggy source:
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.lock.resolveTypes(markers,context);
  this.block.resolveTypes(markers,context);
}

Fixed version (ground truth):
@Override public void resolveTypes(MarkerList markers,IContext context){
  this.lock.resolveTypes(markers,context);
  if (this.block.isStatement()) {
    ((IStatement)this.block).setParent(this);
  }
  this.block.resolveTypes(markers,context);
}
Program: 85054
Project: 85054
Buggy source:
private void write(MethodWriter writer,boolean expression){
  int localCount=writer.registerLocal();
  this.lock.writeExpression(writer);
  writer.writeInsn(Opcodes.DUP);
  writer.writeVarInsn(Opcodes.ASTORE,localCount);
  writer.writeInsn(Opcodes.MONITORENTER);
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerStart=new org.objectweb.asm.Label();
  org.objectweb.asm.Label throwLabel=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerEnd=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  if (expression) {
    this.block.writeExpression(writer);
  }
 else {
    this.block.writeStatement(writer);
  }
  writer.writeVarInsn(Opcodes.ALOAD,localCount);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(end);
  writer.writeJumpInsn(Opcodes.GOTO,handlerEnd);
  writer.writeLabel(handlerStart);
  writer.writeVarInsn(Opcodes.ALOAD,localCount);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(throwLabel);
  writer.writeInsn(Opcodes.ATHROW);
  if (expression) {
    this.block.getType().writeDefaultValue(writer);
  }
  writer.resetLocals(localCount);
  writer.writeLabel(handlerEnd);
  writer.writeFinallyBlock(start,end,handlerStart);
  writer.writeFinallyBlock(handlerStart,throwLabel,handlerStart);
}

Fixed version (ground truth):
private void write(MethodWriter writer,boolean expression){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerStart=new org.objectweb.asm.Label();
  org.objectweb.asm.Label throwLabel=new org.objectweb.asm.Label();
  org.objectweb.asm.Label handlerEnd=new org.objectweb.asm.Label();
  this.lock.writeExpression(writer);
  writer.writeInsn(Opcodes.DUP);
  int varIndex=writer.startSync();
  writer.writeVarInsn(Opcodes.ASTORE,varIndex);
  writer.writeInsn(Opcodes.MONITORENTER);
  writer.writeLabel(start);
  if (expression) {
    this.block.writeExpression(writer);
  }
 else {
    this.block.writeStatement(writer);
  }
  writer.endSync();
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(end);
  writer.writeJumpInsn(Opcodes.GOTO,handlerEnd);
  writer.writeLabel(handlerStart);
  writer.writeVarInsn(Opcodes.ALOAD,varIndex);
  writer.writeInsn(Opcodes.MONITOREXIT);
  writer.writeLabel(throwLabel);
  writer.writeInsn(Opcodes.ATHROW);
  if (expression) {
    this.block.getType().writeDefaultValue(writer);
  }
  writer.resetLocals(varIndex);
  writer.writeLabel(handlerEnd);
  writer.writeFinallyBlock(start,end,handlerStart);
  writer.writeFinallyBlock(handlerStart,throwLabel,handlerStart);
}
Program: 85055
Project: 85055
Buggy source:
@Override public void tokenize(){
  this.tokens=Dlex.tokenIterator(this.inputFile.getCode());
}

Fixed version (ground truth):
@Override public void tokenize(){
  this.tokens=Dlex.tokenIterator(this.inputFile.getCode());
  this.tokens.inferSemicolons();
}
Program: 85056
Project: 85056
Buggy source:
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilHeaderParser(this));
  manager.semicolonInference=true;
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}

Fixed version (ground truth):
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilHeaderParser(this));
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}
Program: 85057
Project: 85057
Buggy source:
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilUnitParser(this));
  manager.semicolonInference=true;
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}

Fixed version (ground truth):
@Override public void parse(){
  ParserManager manager=new ParserManager(new DyvilUnitParser(this));
  manager.operators=this.operators;
  manager.parse(this.markers,this.tokens);
  this.tokens=null;
}
Program: 85058
Project: 85058
Buggy source:
private static int getMode(char c,String code,int i){
switch (c) {
case '"':
    return STRING;
case '\'':
  return CHAR;
case '/':
char n=code.charAt(i + 1);
if (n == '*') {
return BLOCK_COMMENT;
}
 else if (n == '/') {
return LINE_COMMENT;
}
 else {
return IDENTIFIER | MOD_SYMBOL;
}
case '@':
n=code.charAt(i + 1);
if (n == '"') {
return STRING_START;
}
return IDENTIFIER | MOD_SYMBOL;
case '0':
n=code.charAt(i + 1);
if (n == 'b') {
return INT | MOD_BIN;
}
 else if (n == 'x') {
return INT | MOD_HEX;
}
 else if (isDigit(n)) {
return INT | MOD_OCT;
}
return INT;
case '(':
return Symbols.OPEN_PARENTHESIS;
case ')':
return Symbols.CLOSE_PARENTHESIS;
case '[':
return Symbols.OPEN_SQUARE_BRACKET;
case ']':
return Symbols.CLOSE_SQUARE_BRACKET;
case '{':
return Symbols.OPEN_CURLY_BRACKET;
case '}':
return Symbols.CLOSE_CURLY_BRACKET;
case '.':
n=code.charAt(i + 1);
if (n == '.') {
return IDENTIFIER | MOD_DOTS;
}
return Symbols.DOT;
case ';':
return Symbols.SEMICOLON;
case ',':
return Symbols.COMMA;
}
if (isDigit(c)) {
return INT;
}
 else if (isIdentifierSymbol(c)) {
return IDENTIFIER | MOD_SYMBOL;
}
 else if (isIdentifierPart(c)) {
return IDENTIFIER | MOD_LETTER;
}
return 0;
}

Fixed version (ground truth):
private static int getMode(char c,String code,int i){
switch (c) {
case '"':
    return STRING;
case '\'':
  return CHAR;
case '/':
char n=code.charAt(i + 1);
if (n == '*') {
return BLOCK_COMMENT;
}
 else if (n == '/') {
return LINE_COMMENT;
}
 else {
return IDENTIFIER | MOD_SYMBOL;
}
case '@':
n=code.charAt(i + 1);
if (n == '"') {
return STRING_2;
}
return IDENTIFIER | MOD_SYMBOL;
case '0':
n=code.charAt(i + 1);
if (n == 'b') {
return INT | MOD_BIN;
}
 else if (n == 'x') {
return INT | MOD_HEX;
}
 else if (isDigit(n)) {
return INT | MOD_OCT;
}
return INT;
case '(':
return Symbols.OPEN_PARENTHESIS;
case ')':
return Symbols.CLOSE_PARENTHESIS;
case '[':
return Symbols.OPEN_SQUARE_BRACKET;
case ']':
return Symbols.CLOSE_SQUARE_BRACKET;
case '{':
return Symbols.OPEN_CURLY_BRACKET;
case '}':
return Symbols.CLOSE_CURLY_BRACKET;
case '.':
n=code.charAt(i + 1);
if (n == '.') {
return IDENTIFIER | MOD_DOTS;
}
return Symbols.DOT;
case ';':
return Symbols.SEMICOLON;
case ',':
return Symbols.COMMA;
}
if (isDigit(c)) {
return INT;
}
 else if (isIdentifierSymbol(c)) {
return IDENTIFIER | MOD_SYMBOL;
}
 else if (isIdentifierPart(c)) {
return IDENTIFIER | MOD_LETTER;
}
return 0;
}
Program: 85060
Project: 85060
Buggy source:
public final void parse(MarkerList markers,TokenIterator tokens){
  this.tokens=tokens;
  IToken token=null;
  IToken prev=null;
  while (tokens.hasNext()) {
    token=tokens.next();
    if (!this.retainToken(token,prev)) {
      tokens.remove();
    }
    prev=token;
  }
  tokens.reset();
  while (tokens.hasNext()) {
    token=tokens.next();
    token.setPrev(prev);
    prev=token;
  }
  tokens.reset();
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    SyntaxError ex) {
{
        if (ex.reparse) {
          this.reparse=true;
        }
        markers.add(ex);
      }
    }
catch (    Exception ex) {
{
        DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
        markers.add(new SyntaxError(token,"String_Node_Str" + token + "String_Node_Str"+ ex.getMessage()));
      }
    }
    if (this.parser == null) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.name+ "String_Node_Str"+ this.parser.mode);
    }
  }
}

Fixed version (ground truth):
public final void parse(MarkerList markers,TokenIterator tokens){
  this.tokens=tokens;
  IToken token=null;
  while (true) {
    if (this.reparse) {
      this.reparse=false;
    }
 else {
      token=tokens.next();
      if (token == null) {
        break;
      }
    }
    if (this.skip > 0) {
      this.skip--;
      continue;
    }
    try {
      this.parser.parse(this,token);
    }
 catch (    SyntaxError ex) {
{
        if (ex.reparse) {
          this.reparse=true;
        }
        markers.add(ex);
      }
    }
catch (    Exception ex) {
{
        DyvilCompiler.logger.throwing("String_Node_Str","String_Node_Str",ex);
        markers.add(new SyntaxError(token,"String_Node_Str" + token + "String_Node_Str"+ ex.getMessage()));
      }
    }
    if (this.parser == null) {
      break;
    }
    if (DyvilCompiler.parseStack) {
      System.out.println(token + "String_Node_Str" + this.parser.name+ "String_Node_Str"+ this.parser.mode);
    }
  }
}
Program: 85061
Project: 85061
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  Name name=this.type.getName();
  FieldMatch f=context.resolveField(name);
  if (f != null) {
    FieldAccess access=new FieldAccess(this.position);
    access.name=name;
    access.field=f.theField;
    return access;
  }
  IMethod m=IContext.resolveMethod(markers,context,null,name,EmptyArguments.INSTANCE);
  if (m != null) {
    MethodCall call=new MethodCall(this.position);
    call.name=name;
    call.method=m;
    call.dotless=true;
    if (this.type.isGenericType()) {
      GenericType generic=(GenericType)this.type;
      call.generics=generic.generics;
      call.genericCount=generic.genericCount;
    }
    call.arguments=EmptyArguments.INSTANCE;
    return call;
  }
  if (!this.type.isResolved()) {
    markers.add(this.position,this.type.isArrayType() ? "String_Node_Str" : "String_Node_Str",this.type.toString());
  }
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  Name name=this.type.getName();
  IField f=context.resolveField(name);
  if (f != null) {
    FieldAccess access=new FieldAccess(this.position);
    access.name=name;
    access.field=f;
    return access;
  }
  IMethod m=IContext.resolveMethod(markers,context,null,name,EmptyArguments.INSTANCE);
  if (m != null) {
    MethodCall call=new MethodCall(this.position);
    call.name=name;
    call.method=m;
    call.dotless=true;
    if (this.type.isGenericType()) {
      GenericType generic=(GenericType)this.type;
      call.generics=generic.generics;
      call.genericCount=generic.genericCount;
    }
    call.arguments=EmptyArguments.INSTANCE;
    return call;
  }
  if (!this.type.isResolved()) {
    markers.add(this.position,this.type.isArrayType() ? "String_Node_Str" : "String_Node_Str",this.type.toString());
  }
  return this;
}
Program: 85062
Project: 85062
Buggy source:
public static IField resolveField(IContext context,ITyped instance,Name name){
  FieldMatch match;
  if (instance != null) {
    IType type=instance.getType();
    if (type != null) {
      match=type.resolveField(name);
      if (match != null) {
        return match.theField;
      }
    }
  }
  match=context.resolveField(name);
  if (match != null) {
    return match.theField;
  }
  return null;
}

Fixed version (ground truth):
public static IField resolveField(IContext context,ITyped instance,Name name){
  IField match;
  if (instance != null) {
    IType type=instance.getType();
    if (type != null) {
      match=type.resolveField(name);
      if (match != null) {
        return match;
      }
    }
  }
  match=context.resolveField(name);
  if (match != null) {
    return match;
  }
  return null;
}
Program: 85063
Project: 85063
Buggy source:
@Override public IValue resolve2(IContext context){
  if (this.replacement != null) {
    return this.replacement;
  }
  if (this.arguments.isEmpty()) {
    IField field=IAccess.resolveField(context,this.instance,this.name);
    if (field != null) {
      FieldAccess access=new FieldAccess(this.position);
      access.field=field;
      access.instance=this.instance;
      access.name=this.name;
      access.dotless=this.dotless;
      return access;
    }
  }
 else   if (this.instance == null) {
    IValue instance;
    IType type=null;
    IMethod method=null;
    FieldMatch field=context.resolveField(this.name);
    if (field == null) {
      type=new Type(this.position,this.name).resolve(null,context);
      if (!type.isResolved()) {
        return null;
      }
      IMethod match=IContext.resolveMethod(null,type,null,Name.apply,this.arguments);
      if (match == null) {
        return null;
      }
      method=match;
      instance=new ClassAccess(this.position,type);
    }
 else {
      FieldAccess access=new FieldAccess(this.position);
      access.field=field.theField;
      access.name=this.name;
      access.dotless=this.dotless;
      IMethod match=IContext.resolveMethod(null,field.theField.getType(),access,Name.apply,this.arguments);
      if (match == null) {
        return null;
      }
      method=match;
      instance=access;
    }
    ApplyMethodCall call=new ApplyMethodCall(this.position);
    call.method=method;
    call.instance=instance;
    call.arguments=this.arguments;
    return call;
  }
  return null;
}

Fixed version (ground truth):
@Override public IValue resolve2(IContext context){
  if (this.replacement != null) {
    return this.replacement;
  }
  if (this.arguments.isEmpty()) {
    IField field=IAccess.resolveField(context,this.instance,this.name);
    if (field != null) {
      FieldAccess access=new FieldAccess(this.position);
      access.field=field;
      access.instance=this.instance;
      access.name=this.name;
      access.dotless=this.dotless;
      return access;
    }
  }
 else   if (this.instance == null) {
    IValue instance;
    IType type=null;
    IMethod method=null;
    IField field=context.resolveField(this.name);
    if (field == null) {
      type=new Type(this.position,this.name).resolve(null,context);
      if (!type.isResolved()) {
        return null;
      }
      IMethod match=IContext.resolveMethod(null,type,null,Name.apply,this.arguments);
      if (match == null) {
        return null;
      }
      method=match;
      instance=new ClassAccess(this.position,type);
    }
 else {
      FieldAccess access=new FieldAccess(this.position);
      access.field=field;
      access.name=this.name;
      access.dotless=this.dotless;
      IMethod match=IContext.resolveMethod(null,field.getType(),access,Name.apply,this.arguments);
      if (match == null) {
        return null;
      }
      method=match;
      instance=access;
    }
    ApplyMethodCall call=new ApplyMethodCall(this.position);
    call.method=method;
    call.instance=instance;
    call.arguments=this.arguments;
    return call;
  }
  return null;
}
Program: 85064
Project: 85064
Buggy source:
@Override public FieldMatch resolveField(Name name){
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    if (param.getName() == name) {
      return new FieldMatch(param,1);
    }
  }
  if (this.body != null) {
    IField field=this.body.getProperty(name);
    if (field != null) {
      return new FieldMatch(field,1);
    }
    field=this.body.getField(name);
    if (field != null) {
      return new FieldMatch(field,1);
    }
  }
  FieldMatch match=this.metadata.resolveField(name);
  if (match != null) {
    return match;
  }
  if (this.superType != null) {
    match=this.superType.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  if (this.unit != null && this.unit.hasStaticImports()) {
    match=this.unit.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  for (int i=0; i < this.parameterCount; i++) {
    IParameter param=this.parameters[i];
    if (param.getName() == name) {
      return param;
    }
  }
  if (this.body != null) {
    IField field=this.body.getProperty(name);
    if (field != null) {
      return field;
    }
    field=this.body.getField(name);
    if (field != null) {
      return field;
    }
  }
  IField match=this.metadata.resolveField(name);
  if (match != null) {
    return match;
  }
  if (this.superType != null) {
    match=this.superType.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  if (this.unit != null && this.unit.hasStaticImports()) {
    match=this.unit.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}
Program: 85065
Project: 85065
Buggy source:
public default FieldMatch resolveField(Name name){
  return null;
}

Fixed version (ground truth):
public default IField resolveField(Name name){
  return null;
}
Program: 85066
Project: 85066
Buggy source:
@Override public FieldMatch resolveField(Name name){
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  return null;
}
Program: 85067
Project: 85067
Buggy source:
@Override public FieldMatch resolveField(Name name){
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  return null;
}
Program: 85068
Project: 85068
Buggy source:
@Override public FieldMatch resolveField(Name name){
  IField field=this.body.getProperty(name);
  if (field != null) {
    return new FieldMatch(field,1);
  }
  field=this.body.getField(name);
  if (field != null) {
    return new FieldMatch(field,1);
  }
  FieldMatch match;
  if (!this.superTypesResolved) {
    this.resolveSuperTypes();
  }
  if (this.superType != null) {
    match=this.superType.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  IField field=this.body.getProperty(name);
  if (field != null) {
    return field;
  }
  field=this.body.getField(name);
  if (field != null) {
    return field;
  }
  if (!this.superTypesResolved) {
    this.resolveSuperTypes();
  }
  if (this.superType != null) {
    IField match=this.superType.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}
Program: 85069
Project: 85069
Buggy source:
@Override public FieldMatch resolveField(Name name){
  if (name == this.name) {
    return new FieldMatch(this.setterParameter,1);
  }
  return this.theClass.resolveField(name);
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  if (name == this.name) {
    return this.setterParameter;
  }
  return this.theClass.resolveField(name);
}
Program: 85070
Project: 85070
Buggy source:
@Override public FieldMatch resolveField(Name name){
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  return null;
}
Program: 85071
Project: 85071
Buggy source:
@Override public FieldMatch resolveField(Name name){
  if (this.arrayDimensions > 0 || this.upperBoundCount == 0) {
    return null;
  }
  for (int i=0; i < this.upperBoundCount; i++) {
    FieldMatch f=this.upperBounds[i].resolveField(name);
    if (f != null) {
      return f;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  if (this.arrayDimensions > 0 || this.upperBoundCount == 0) {
    return null;
  }
  for (int i=0; i < this.upperBoundCount; i++) {
    IField f=this.upperBounds[i].resolveField(name);
    if (f != null) {
      return f;
    }
  }
  return null;
}
Program: 85072
Project: 85072
Buggy source:
@Override public FieldMatch resolveField(Name name){
  return this.last.resolveField(name);
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  return this.last.resolveField(name);
}
Program: 85073
Project: 85073
Buggy source:
@Override public FieldMatch resolveField(Name name){
  for (  IImport i : this.children) {
    FieldMatch match=i.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  for (  IImport i : this.children) {
    IField match=i.resolveField(name);
    if (match != null) {
      return match;
    }
  }
  return null;
}
Program: 85074
Project: 85074
Buggy source:
@Override public FieldMatch resolveField(Name name){
  return this.theClass.resolveField(name);
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  return this.theClass.resolveField(name);
}
Program: 85075
Project: 85075
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString(prefix,buffer);
  }
  if (Formatting.Method.convertQualifiedNames) {
    buffer.append(this.name.qualified).append("String_Node_Str");
  }
 else {
    buffer.append(this.name.unqualified).append('=');
  }
  this.arguments.toString(prefix,buffer);
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString(prefix,buffer);
    buffer.append(' ');
  }
  if (Formatting.Method.convertQualifiedNames) {
    buffer.append(this.name.qualified).append("String_Node_Str");
  }
 else {
    buffer.append(this.name.unqualified).append('=');
  }
  this.arguments.toString(prefix,buffer);
}
Program: 85076
Project: 85076
Buggy source:
public InvokeDynamicInstruction(String name,String type,Handle bsm,Object[] bsmArguments){
  this.name=name;
  this.type=type;
  this.bsm=bsm;
  this.bsmArguments=bsmArguments;
}

Fixed version (ground truth):
public InvokeDynamicInstruction(String name,String type,Handle bsm,Object[] bsmArguments){
  this.name=name;
  this.type=type;
  this.bsm=bsm;
  this.bsmArguments=bsmArguments;
  this.type=type.substring(type.lastIndexOf(')') + 1);
  this.args=Type.getArgumentsAndReturnSizes(type) >> 2;
}
Program: 85077
Project: 85077
Buggy source:
@Override public void write(MethodWriter writer){
}

Fixed version (ground truth):
@Override public void write(MethodWriter writer){
  writer.writeInvokeDynamic(this.name,this.type,this.args,this.returnType,this.bsm,this.bsmArguments);
}
Program: 85078
Project: 85078
Buggy source:
@Override public void write(MethodWriter writer){
}

Fixed version (ground truth):
@Override public void write(MethodWriter writer){
  int len=this.handlers.length;
  org.objectweb.asm.Label[] labels=new org.objectweb.asm.Label[len];
  for (int i=0; i < len; i++) {
    labels[i]=this.handlers[i].target;
  }
  writer.writeLookupSwitch(this.defaultHandler.target,this.keys,labels);
}
Program: 85079
Project: 85079
Buggy source:
@Override public void write(MethodWriter writer){
}

Fixed version (ground truth):
@Override public void write(MethodWriter writer){
  int len=this.handlers.length;
  org.objectweb.asm.Label[] labels=new org.objectweb.asm.Label[len];
  for (int i=0; i < len; i++) {
    labels[i]=this.handlers[i].target;
  }
  writer.writeTableSwitch(this.defaultHandler.target,this.start,this.end,labels);
}
Program: 85080
Project: 85080
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString("String_Node_Str",buffer);
    buffer.append('.');
  }
  buffer.append(this.name);
  if (this.value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    Formatting.appendValue(this.value,prefix,buffer);
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString("String_Node_Str",buffer);
    buffer.append('.');
  }
  buffer.append(this.name);
  if (this.value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    this.value.toString(prefix,buffer);
  }
}
Program: 85081
Project: 85081
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString(prefix,buffer);
  }
  if (this.arguments instanceof ArgumentList) {
    buffer.append(Formatting.Method.parametersStart);
    int len=this.arguments.size() - 1;
    this.arguments.getValue(0,null).toString(prefix,buffer);
    for (int i=1; i < len; i++) {
      buffer.append(Formatting.Method.parameterSeperator);
      this.arguments.getValue(i,null).toString(prefix,buffer);
    }
    buffer.append(Formatting.Method.parametersEnd);
    buffer.append(Formatting.Field.keyValueSeperator);
    Formatting.appendValue(this.arguments.getValue(len,null),prefix,buffer);
  }
 else {
    this.arguments.toString(prefix,buffer);
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  if (this.instance != null) {
    this.instance.toString(prefix,buffer);
  }
  if (this.arguments instanceof ArgumentList) {
    buffer.append(Formatting.Method.parametersStart);
    int len=this.arguments.size() - 1;
    this.arguments.getValue(0,null).toString(prefix,buffer);
    for (int i=1; i < len; i++) {
      buffer.append(Formatting.Method.parameterSeperator);
      this.arguments.getValue(i,null).toString(prefix,buffer);
    }
    buffer.append(Formatting.Method.parametersEnd);
    buffer.append(Formatting.Field.keyValueSeperator);
    this.arguments.getValue(len,null).toString(prefix,buffer);
  }
 else {
    this.arguments.toString(prefix,buffer);
  }
}
Program: 85082
Project: 85082
Buggy source:
public void setDesc(String desc){
  this.desc=desc;
}

Fixed version (ground truth):
public void setDesc(String desc){
  this.desc=ClassFormat.userToExtended(desc);
}
Program: 85083
Project: 85083
Buggy source:
@Override public void write(MethodWriter writer){
  String s=ClassFormat.userToExtended(this.desc);
  writer.writeFieldInsn(this.opcode,this.owner,this.fieldName,s);
}

Fixed version (ground truth):
@Override public void write(MethodWriter writer){
  writer.writeFieldInsn(this.opcode,this.owner,this.fieldName,this.desc);
}
Program: 85084
Project: 85084
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.FIELD.toString(this.modifiers));
  this.type.toString("String_Node_Str",buffer);
  buffer.append(' ');
  buffer.append(this.name);
  IValue value=this.value;
  if (value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    Formatting.appendValue(value,prefix,buffer);
  }
  buffer.append(';');
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.FIELD.toString(this.modifiers));
  this.type.toString("String_Node_Str",buffer);
  buffer.append(' ');
  buffer.append(this.name);
  if (this.value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    this.value.toString(prefix,buffer);
  }
  buffer.append(';');
}
Program: 85085
Project: 85085
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  this.type.toString("String_Node_Str",buffer);
  buffer.append(' ').append(this.name);
  if (this.value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    Formatting.appendValue(this.value,prefix,buffer);
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  this.type.toString("String_Node_Str",buffer);
  buffer.append(' ').append(this.name);
  if (this.value != null) {
    buffer.append(Formatting.Field.keyValueSeperator);
    this.value.toString(prefix,buffer);
  }
}
Program: 85086
Project: 85086
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.METHOD.toString(this.modifiers));
  buffer.append("String_Node_Str");
  buffer.append(Formatting.Method.parametersStart);
  Util.astToString(prefix,this.parameters,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
  buffer.append(Formatting.Method.parametersEnd);
  if (this.exceptionCount > 0) {
    buffer.append(Formatting.Method.signatureThrowsSeperator);
    Util.astToString(prefix,this.exceptions,this.exceptionCount,Formatting.Method.throwsSeperator,buffer);
  }
  IValue value=this.getValue();
  if (value != null) {
    buffer.append(Formatting.Method.signatureBodySeperator);
    Formatting.appendValue(value,prefix,buffer);
  }
  buffer.append(';');
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.METHOD.toString(this.modifiers));
  buffer.append("String_Node_Str");
  buffer.append(Formatting.Method.parametersStart);
  Util.astToString(prefix,this.parameters,this.parameterCount,Formatting.Method.parameterSeperator,buffer);
  buffer.append(Formatting.Method.parametersEnd);
  if (this.exceptionCount > 0) {
    buffer.append(Formatting.Method.signatureThrowsSeperator);
    Util.astToString(prefix,this.exceptions,this.exceptionCount,Formatting.Method.throwsSeperator,buffer);
  }
  if (this.value != null) {
    buffer.append(Formatting.Method.signatureBodySeperator);
    this.value.toString(prefix,buffer);
  }
  buffer.append(';');
}
Program: 85087
Project: 85087
Buggy source:
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if (instance != null && (this.modifiers & Modifiers.STATIC) != 0 && instance.getValueType() == IValue.CLASS_ACCESS) {
    instance=null;
  }
  if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}

Fixed version (ground truth):
@Override public void writeInvJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if (instance != null && (this.modifiers & Modifiers.STATIC) != 0 && instance.getValueType() == IValue.CLASS_ACCESS) {
    instance=null;
  }
  if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeInvIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() == 0) {
    Label inlineEnd=new Label();
    this.writeInlineArguments(writer,instance,arguments,writer.startInline(inlineEnd));
    this.value.writeInvJump(writer,dest);
    writer.endInline(inlineEnd);
    return;
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFNE,dest);
}
Program: 85088
Project: 85088
Buggy source:
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if (instance != null && (this.modifiers & Modifiers.STATIC) != 0 && instance.getValueType() == IValue.CLASS_ACCESS) {
    instance=null;
  }
  if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}

Fixed version (ground truth):
@Override public void writeJump(MethodWriter writer,Label dest,IValue instance,IArguments arguments){
  if (instance != null && (this.modifiers & Modifiers.STATIC) != 0 && instance.getValueType() == IValue.CLASS_ACCESS) {
    instance=null;
  }
  if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    this.writeIntrinsic(writer,dest,instance,arguments);
    return;
  }
  if ((this.modifiers & INLINABLE) != 0 && writer.inlineOffset() == 0) {
    Label inlineEnd=new Label();
    this.writeInlineArguments(writer,instance,arguments,writer.startInline(inlineEnd));
    this.value.writeJump(writer,dest);
    writer.endInline(inlineEnd);
    return;
  }
  this.writeInvoke(writer,instance,arguments);
  writer.writeJumpInsn(IFEQ,dest);
}