nus-yam/ex-repair huggingface dataset:
Program: 83759
Project: 83759
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: 83761
Project: 83761
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: 83762
Project: 83762
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: 83763
Project: 83763
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: 83764
Project: 83764
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: 83765
Project: 83765
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: 83766
Project: 83766
Buggy source:
public default FieldMatch resolveField(Name name){
  return null;
}

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

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

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  return null;
}
Program: 83769
Project: 83769
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: 83770
Project: 83770
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: 83771
Project: 83771
Buggy source:
@Override public FieldMatch resolveField(Name name){
  return null;
}

Fixed version (ground truth):
@Override public IField resolveField(Name name){
  return null;
}
Program: 83772
Project: 83772
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: 83773
Project: 83773
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: 83774
Project: 83774
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: 83775
Project: 83775
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: 83776
Project: 83776
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: 83777
Project: 83777
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: 83778
Project: 83778
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: 83779
Project: 83779
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: 83780
Project: 83780
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: 83781
Project: 83781
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: 83782
Project: 83782
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: 83783
Project: 83783
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: 83784
Project: 83784
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: 83785
Project: 83785
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: 83786
Project: 83786
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: 83787
Project: 83787
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: 83788
Project: 83788
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: 83789
Project: 83789
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);
}
Program: 83791
Project: 83791
Buggy source:
@Override public void writeCall(MethodWriter writer,IValue instance,IArguments arguments,IType type){
  if (instance != null && (this.modifiers & Modifiers.STATIC) != 0 && instance.getValueType() == IValue.CLASS_ACCESS) {
    instance=null;
  }
  if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    if (this.type.getTheClass() == Types.BOOLEAN_CLASS) {
      Label ifEnd=new Label();
      Label elseEnd=new Label();
      this.writeIntrinsic(writer,ifEnd,instance,arguments);
      writer.writeLDC(0);
      writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
      writer.writeLabel(ifEnd);
      writer.writeLDC(1);
      writer.writeLabel(elseEnd);
      return;
    }
    this.writeIntrinsic(writer,instance,arguments);
    return;
  }
  if ((this.modifiers & Modifiers.INLINE) != 0) {
    this.writeInline(writer,instance,arguments);
    return;
  }
  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 (instance != null && (this.modifiers & Modifiers.STATIC) != 0 && instance.getValueType() == IValue.CLASS_ACCESS) {
    instance=null;
  }
  if (this.intrinsicOpcodes != null && (instance == null || instance.isPrimitive())) {
    if (this.type.getTheClass() == Types.BOOLEAN_CLASS) {
      Label ifEnd=new Label();
      Label elseEnd=new Label();
      this.writeIntrinsic(writer,ifEnd,instance,arguments);
      writer.writeLDC(0);
      writer.writeJumpInsn(Opcodes.GOTO,elseEnd);
      writer.writeLabel(ifEnd);
      writer.writeLDC(1);
      writer.writeLabel(elseEnd);
      return;
    }
    this.writeIntrinsic(writer,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.writeExpression(writer);
    writer.endInline(inlineEnd);
    return;
  }
  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: 83792
Project: 83792
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  super.toString(prefix,buffer);
  buffer.append(ModifierTypes.METHOD.toString(this.modifiers));
  if (this.type != null) {
    this.type.toString("String_Node_Str",buffer);
    buffer.append(' ');
  }
  buffer.append(this.name);
  if (this.genericCount > 0) {
    buffer.append('[');
    Util.astToString(prefix,this.generics,this.genericCount,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  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));
  if (this.type != null) {
    this.type.toString("String_Node_Str",buffer);
    buffer.append(' ');
  }
  buffer.append(this.name);
  if (this.genericCount > 0) {
    buffer.append('[');
    Util.astToString(prefix,this.generics,this.genericCount,Formatting.Type.genericSeperator,buffer);
    buffer.append(']');
  }
  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: 83793
Project: 83793
Buggy source:
@Override public boolean isType(IType type){
  if (type == Types.VOID || type == Types.UNKNOWN) {
    return true;
  }
  if (this.commonType != null) {
    return type.isSuperTypeOf(this.commonType);
  }
  if (this.then != null) {
    if (this.elseThen != null) {
      if (this.then.isType(type) && this.elseThen.isType(type)) {
        this.commonType=type;
        return true;
      }
    }
 else {
      return this.then.isType(type);
    }
  }
  return false;
}

Fixed version (ground truth):
@Override public boolean isType(IType type){
  if (type == Types.VOID) {
    return true;
  }
  if (this.then != null && !this.then.isType(type)) {
    return false;
  }
  if (this.elseThen != null && !this.elseThen.isType(type)) {
    return false;
  }
  return true;
}
Program: 83794
Project: 83794
Buggy source:
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.ifStart);
  if (this.condition != null) {
    this.condition.toString(prefix,buffer);
  }
  buffer.append(Formatting.Statements.ifEnd);
  if (this.then != null) {
    Formatting.appendValue(this.then,prefix,buffer);
    if (this.elseThen != null) {
      if (this.then.isStatement()) {
        buffer.append('\n').append(prefix);
      }
 else {
        buffer.append(' ');
      }
      buffer.append(Formatting.Statements.ifElse);
      Formatting.appendValue(this.elseThen,prefix,buffer);
    }
  }
}

Fixed version (ground truth):
@Override public void toString(String prefix,StringBuilder buffer){
  buffer.append(Formatting.Statements.ifStart);
  if (this.condition != null) {
    this.condition.toString(prefix,buffer);
  }
  buffer.append(Formatting.Statements.ifEnd);
  if (this.then != null) {
    this.then.toString(prefix,buffer);
    if (this.elseThen != null) {
      if (this.then.isStatement()) {
        buffer.append('\n').append(prefix);
      }
 else {
        buffer.append(' ');
      }
      buffer.append(Formatting.Statements.ifElse);
      this.elseThen.toString(prefix,buffer);
    }
  }
}
Program: 83795
Project: 83795
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  for (int i=0; i < this.instructionCount; i++) {
    if (this.labels != null && i < this.labels.length) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeLabel(l.target);
      }
    }
    this.instructions[i].write(writer);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  if (this.labels == null) {
    for (int i=0; i < this.instructionCount; i++) {
      this.instructions[i].write(writer);
    }
    return;
  }
  for (int i=0; i < this.labels.length; i++) {
    Label l=this.labels[i];
    if (l != null) {
      l.target=new org.objectweb.asm.Label();
    }
  }
  for (int i=0; i < this.instructionCount; i++) {
    if (i < this.labels.length) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeLabel(l.target);
      }
    }
    this.instructions[i].write(writer);
  }
}
Program: 83796
Project: 83796
Buggy source:
@Override public void write(MethodWriter writer){
  writer.writeIINC(this.index,this.value);
}

Fixed version (ground truth):
@Override public void write(MethodWriter writer){
  writer.writeIINC(this.index + writer.inlineOffset(),this.value);
}
Program: 83797
Project: 83797
Buggy source:
@Override public void write(MethodWriter writer){
  writer.writeVarInsn(this.opcode,this.index);
}

Fixed version (ground truth):
@Override public void write(MethodWriter writer){
  writer.writeVarInsn(this.opcode,this.index + writer.inlineOffset());
}
Program: 83799
Project: 83799
Buggy source:
private void writeInline(MethodWriter writer,IValue instance,IArguments arguments){
  Label inlineEnd=new Label();
  int localCount=writer.registerLocal();
  writer.startInline(inlineEnd);
  if (instance != null) {
    instance.writeExpression(writer);
    writer.writeVarInsn(instance.getType().getStoreOpcode(),localCount);
  }
  this.writeInlineArguments(writer,arguments,localCount);
  this.value.writeExpression(writer);
  writer.endInline(inlineEnd);
  writer.resetLocals(localCount);
}

Fixed version (ground truth):
private void writeInline(MethodWriter writer,IValue instance,IArguments arguments){
  Label inlineEnd=new Label();
  int localCount=writer.startInline(inlineEnd);
  if (instance != null) {
    instance.writeExpression(writer);
    writer.writeVarInsn(instance.getType().getStoreOpcode(),localCount);
  }
  this.writeInlineArguments(writer,arguments,localCount);
  this.value.writeExpression(writer);
  writer.endInline(inlineEnd);
}
Program: 83800
Project: 83800
Buggy source:
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value){
  value.writeExpression(writer);
  writer.writeVarInsn(this.type.getStoreOpcode(),this.index);
}

Fixed version (ground truth):
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value){
  if (value != null) {
    value.writeExpression(writer);
  }
  writer.writeVarInsn(this.type.getStoreOpcode(),this.index);
}
Program: 83801
Project: 83801
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=new org.objectweb.asm.Label();
  writer.writeLabel(startLabel);
  this.action.writeStatement(writer);
  writer.writeLabel(this.conditionLabel.target);
  this.condition.writeJump(writer,startLabel);
  writer.writeLabel(this.endLabel.target);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label conditionLabel=this.conditionLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeLabel(startLabel);
  this.action.writeStatement(writer);
  writer.writeLabel(conditionLabel);
  this.condition.writeJump(writer,startLabel);
  writer.writeLabel(endLabel);
}
Program: 83802
Project: 83802
Buggy source:
public DoStatement(ICodePosition position){
  this.position=position;
  this.conditionLabel=new Label($doCondition);
  this.endLabel=new Label($doEnd);
}

Fixed version (ground truth):
public DoStatement(ICodePosition position){
  this.position=position;
  this.startLabel=new Label($doStart);
  this.conditionLabel=new Label($doCondition);
  this.endLabel=new Label($doEnd);
}
Program: 83804
Project: 83804
Buggy source:
public Label(org.objectweb.asm.Label target,Name name){
  this.target=target;
  this.name=name;
}

Fixed version (ground truth):
public Label(Name name,IValue value){
  this.name=name;
  this.value=value;
}
Program: 83805
Project: 83805
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  writer.writeLabel(this.startLabel.target);
  this.condition.writeInvJump(writer,this.endLabel.target);
  this.action.writeStatement(writer);
  writer.writeJumpInsn(Opcodes.GOTO,this.startLabel.target);
  writer.writeLabel(this.endLabel.target);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  if (this.action == null) {
    this.condition.writeStatement(writer);
  }
  org.objectweb.asm.Label startLabel=this.startLabel.target=new org.objectweb.asm.Label();
  org.objectweb.asm.Label endLabel=this.endLabel.target=new org.objectweb.asm.Label();
  writer.writeLabel(startLabel);
  this.condition.writeInvJump(writer,endLabel);
  this.action.writeStatement(writer);
  writer.writeJumpInsn(Opcodes.GOTO,startLabel);
  writer.writeLabel(endLabel);
}
Program: 83806
Project: 83806
Buggy source:
public void startInline(Label end);

Fixed version (ground truth):
public int startInline(Label end);
Program: 83807
Project: 83807
Buggy source:
@Override public void startInline(Label end){
  this.inlineEnd=end;
}

Fixed version (ground truth):
@Override public int startInline(Label end){
  this.inlineEnd=end;
  this.inlineOffset+=this.localIndex;
  return this.localIndex;
}
Program: 83808
Project: 83808
Buggy source:
@Override public void writeLabel(Label label){
  this.mv.visitLabel(label);
}

Fixed version (ground truth):
@Override public void writeLabel(Label label){
  if (this.hasReturn && this.inlineEnd != null) {
    this.writeInlineReturn();
  }
  this.hasReturn=false;
  this.mv.visitLabel(label);
}
Program: 83809
Project: 83809
Buggy source:
@Override public void endInline(Label end){
  this.mv.visitLabel(end);
  this.inlineEnd=null;
  this.hasReturn=false;
}

Fixed version (ground truth):
@Override public void endInline(Label end){
  this.mv.visitLabel(end);
  this.inlineEnd=null;
  this.inlineOffset=this.localIndex;
  this.hasReturn=false;
}
Program: 83810
Project: 83810
Buggy source:
@Override public IValue resolve(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolve(markers,context);
  }
  this.arguments.resolve(markers,context);
  IMethod method=IAccess.resolveMethod(context,this.instance,this.name,this.arguments);
  if (method != null) {
    this.method=method;
    return this;
  }
  Marker marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  marker.addInfo("String_Node_Str" + this.name.unqualified);
  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());
  return this;
}

Fixed version (ground truth):
@Override public IValue resolve(MarkerList markers,IContext context){
  if (this.instance != null) {
    this.instance.resolve(markers,context);
  }
  this.arguments.resolve(markers,context);
  IMethod method=IAccess.resolveMethod(context,this.instance,this.name,this.arguments);
  if (method != null) {
    this.method=method;
    return this;
  }
  Marker marker=markers.create(this.position,"String_Node_Str",this.name.unqualified);
  marker.addInfo("String_Node_Str" + this.name.unqualified);
  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());
  return this;
}
Program: 83811
Project: 83811
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  this.variable.value.writeExpression(writer);
  this.variable.writeSet(writer,null,null);
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  this.variable.value.writeExpression(writer);
  this.variable.index=writer.registerLocal();
  this.variable.writeSet(writer,null,null);
}
Program: 83812
Project: 83812
Buggy source:
@Override public void writeExpression(MethodWriter writer){
  this.variable.value.writeExpression(writer);
  writer.writeInsn(Opcodes.DUP);
  this.variable.writeSet(writer,null,null);
}

Fixed version (ground truth):
@Override public void writeExpression(MethodWriter writer){
}
Program: 83813
Project: 83813
Buggy source:
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value){
  if (value != null) {
    value.writeExpression(writer);
  }
  if (this.index == -1) {
    writer.writeVarInsn(this.type.getStoreOpcode(),this.index=writer.registerLocal());
  }
 else {
    writer.writeVarInsn(this.type.getStoreOpcode(),this.index);
  }
}

Fixed version (ground truth):
@Override public void writeSet(MethodWriter writer,IValue instance,IValue value){
  if (value != null) {
    value.writeExpression(writer);
  }
  writer.writeVarInsn(this.type.getStoreOpcode(),this.index);
}
Program: 83816
Project: 83816
Buggy source:
private void writeInline(MethodWriter writer,IValue instance,IArguments arguments){
  Label inlineEnd=new Label();
  writer.startInline(inlineEnd);
  if (instance != null) {
    instance.writeExpression(writer);
    writer.writeVarInsn(instance.getType().getStoreOpcode(),0);
  }
  this.writeInlineArguments(writer,arguments);
  this.value.writeExpression(writer);
  writer.endInline(inlineEnd);
}

Fixed version (ground truth):
private void writeInline(MethodWriter writer,IValue instance,IArguments arguments){
  Label inlineEnd=new Label();
  int localCount=writer.registerLocal();
  writer.startInline(inlineEnd);
  if (instance != null) {
    instance.writeExpression(writer);
    writer.writeVarInsn(instance.getType().getStoreOpcode(),localCount);
  }
  this.writeInlineArguments(writer,arguments,localCount);
  this.value.writeExpression(writer);
  writer.endInline(inlineEnd);
  writer.resetLocals(localCount);
}
Program: 83817
Project: 83817
Buggy source:
@Override public void writeStatement(MethodWriter writer){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  int count=writer.registerLocal();
  if (this.labels == null) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].writeStatement(writer);
    }
  }
 else {
    for (int i=0; i < this.valueCount; i++) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeLabel(l.target);
      }
      this.values[i].writeStatement(writer);
    }
  }
  if (!this.topLevel) {
    writer.resetLocals(count);
  }
  writer.writeLabel(end);
  if (this.variables == null) {
    return;
  }
  for (  Entry<Name,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.writeLocal(var.name.qualified,var.type.getExtendedName(),var.type.getSignature(),start,end,var.index);
  }
}

Fixed version (ground truth):
@Override public void writeStatement(MethodWriter writer){
  org.objectweb.asm.Label start=new org.objectweb.asm.Label();
  org.objectweb.asm.Label end=new org.objectweb.asm.Label();
  writer.writeLabel(start);
  int count=writer.registerLocal();
  if (this.labels == null) {
    for (int i=0; i < this.valueCount; i++) {
      this.values[i].writeStatement(writer);
    }
  }
 else {
    for (int i=0; i < this.valueCount; i++) {
      Label l=this.labels[i];
      if (l != null) {
        writer.writeLabel(l.target);
      }
      this.values[i].writeStatement(writer);
    }
  }
  writer.resetLocals(count);
  writer.writeLabel(end);
  if (this.variables == null) {
    return;
  }
  for (  Entry<Name,Variable> entry : this.variables.entrySet()) {
    Variable var=entry.getValue();
    writer.writeLocal(var.name.qualified,var.type.getExtendedName(),var.type.getSignature(),start,end,var.index);
  }
}