nus-yam/ex-repair huggingface dataset:
Program: 175380
Project: 175380
Buggy source:
public PreviewChunk(ChunkPrimer chunk,Biome[] biomes,ChunkPos pos,IBlockAccess previewAccess){
  this.chunk=chunk;
  this.biomes=biomes;
  this.pos=pos;
  this.previewAccess=previewAccess;
}

Fixed version (ground truth):
public PreviewChunk(ChunkPrimer chunk,Biome[] biomes,ChunkPos pos,IBlockAccess previewAccess){
  this.chunk=chunk;
  this.biomes=biomes;
  this.pos=pos;
  this.previewAccess=previewAccess;
  this.globalX=this.pos.getXStart();
  this.globalZ=this.pos.getZStart();
}
Program: 175381
Project: 175381
Buggy source:
public void buildBlocks(BufferBuilder builder){
  builder.begin(GL11.GL_QUADS,TerrariumVertexFormats.POSITION_COLOR_NORMAL);
  ChunkPrimer chunk=this.chunk;
  IBlockAccess previewAccess=this.previewAccess;
  int globalX=this.pos.x << 4;
  int globalZ=this.pos.z << 4;
  BlockPos.MutableBlockPos pos=new BlockPos.MutableBlockPos();
  for (int z=0; z < 16; z++) {
    for (int x=0; x < 16; x++) {
      Biome biome=this.biomes[x + z * 16];
      for (int y=0; y < 256; y++) {
        IBlockState state=chunk.getBlockState(x,y,z);
        if (state.getBlock() != Blocks.AIR) {
          pos.setPos(globalX + x,y,globalZ + z);
          List<EnumFacing> faces=new ArrayList<>(6);
          for (          EnumFacing facing : PREVIEW_FACES) {
            BlockPos offset=pos.offset(facing);
            IBlockState neighbourState;
            if (x > 0 && x < 15 && z > 0 && z < 15 && y > 0 && y < 255) {
              neighbourState=chunk.getBlockState(offset.getX() & 15,offset.getY(),offset.getZ() & 15);
            }
 else {
              neighbourState=previewAccess.getBlockState(offset);
            }
            if (neighbourState.getBlock() == Blocks.AIR) {
              faces.add(facing);
            }
          }
          if (!faces.isEmpty()) {
            this.buildFaces(builder,faces,state,biome,pos);
          }
        }
      }
    }
  }
  builder.setTranslation(0.0,0.0,0.0);
}

Fixed version (ground truth):
public void buildBlocks(BufferBuilder builder){
  builder.begin(GL11.GL_QUADS,TerrariumVertexFormats.POSITION_COLOR_NORMAL);
  ChunkPrimer chunk=this.chunk;
  IBlockAccess previewAccess=this.previewAccess;
  int globalX=this.globalX;
  int globalZ=this.globalZ;
  BlockPos.MutableBlockPos pos=new BlockPos.MutableBlockPos();
  for (int z=0; z < 16; z++) {
    for (int x=0; x < 16; x++) {
      Biome biome=this.biomes[x + z * 16];
      for (int y=0; y < 256; y++) {
        IBlockState state=chunk.getBlockState(x,y,z);
        if (state.getBlock() != Blocks.AIR) {
          pos.setPos(globalX + x,y,globalZ + z);
          List<EnumFacing> faces=new ArrayList<>(6);
          for (          EnumFacing facing : PREVIEW_FACES) {
            BlockPos offset=pos.offset(facing);
            IBlockState neighbourState;
            if (x > 0 && x < 15 && z > 0 && z < 15 && y > 0 && y < 255) {
              neighbourState=chunk.getBlockState(offset.getX() & 15,offset.getY(),offset.getZ() & 15);
            }
 else {
              neighbourState=previewAccess.getBlockState(offset);
            }
            if (neighbourState.getBlock() == Blocks.AIR) {
              faces.add(facing);
            }
          }
          if (!faces.isEmpty()) {
            this.buildFaces(builder,faces,state,biome,pos,x,z);
          }
        }
      }
    }
  }
  builder.setTranslation(0.0,0.0,0.0);
}
Program: 175382
Project: 175382
Buggy source:
public void render(WorldPreview preview,float zoom,float rotationX,float rotationY){
  this.renderBackground();
  if (preview != null) {
    ScaledResolution resolution=new ScaledResolution(MC);
    double scaleFactor=resolution.getScaleFactor();
    BlockPos centerPos=preview.getCenterBlockPos();
    GlStateManager.pushMatrix();
    GlStateManager.scale(scaleFactor,scaleFactor,scaleFactor);
    GL11.glEnable(GL11.GL_SCISSOR_TEST);
    GuiRenderUtils.scissor(this.x,this.y,this.width,this.height);
    GlStateManager.enableRescaleNormal();
    GlStateManager.disableTexture2D();
    GlStateManager.enableDepth();
    GlStateManager.translate(this.gui.width / scaleFactor / 2.0,(this.y + this.height / 2) / scaleFactor,0.0);
    GlStateManager.scale(zoom,-zoom,zoom);
    GlStateManager.rotate(rotationX,1.0F,0.0F,0.0F);
    GlStateManager.rotate(rotationY,0.0F,1.0F,0.0F);
    GlStateManager.translate(-centerPos.getX(),-preview.getHeightOffset(),-centerPos.getZ());
    RenderHelper.enableStandardItemLighting();
    preview.render();
    GlStateManager.disableLighting();
    GlStateManager.disableDepth();
    GlStateManager.enableTexture2D();
    GlStateManager.disableRescaleNormal();
    GL11.glDisable(GL11.GL_SCISSOR_TEST);
    GlStateManager.popMatrix();
  }
}

Fixed version (ground truth):
public void render(WorldPreview preview,float zoom,float rotationX,float rotationY){
  this.renderBackground();
  if (preview != null) {
    ScaledResolution resolution=new ScaledResolution(MC);
    double scaleFactor=resolution.getScaleFactor();
    GlStateManager.pushMatrix();
    GlStateManager.scale(scaleFactor,scaleFactor,scaleFactor);
    GL11.glEnable(GL11.GL_SCISSOR_TEST);
    GuiRenderUtils.scissor(this.x,this.y,this.width,this.height);
    GlStateManager.enableRescaleNormal();
    GlStateManager.disableTexture2D();
    GlStateManager.enableDepth();
    GlStateManager.translate(this.gui.width / scaleFactor / 2.0,(this.y + this.height / 2) / scaleFactor,0.0);
    GlStateManager.scale(zoom,-zoom,zoom);
    GlStateManager.rotate(rotationX,1.0F,0.0F,0.0F);
    GlStateManager.rotate(rotationY,0.0F,1.0F,0.0F);
    GlStateManager.translate(0.0,-preview.getHeightOffset(),0.0);
    RenderHelper.enableStandardItemLighting();
    preview.render();
    GlStateManager.disableLighting();
    GlStateManager.disableDepth();
    GlStateManager.enableTexture2D();
    GlStateManager.disableRescaleNormal();
    GL11.glDisable(GL11.GL_SCISSOR_TEST);
    GlStateManager.popMatrix();
  }
}
Program: 175383
Project: 175383
Buggy source:
public void render(){
  List<PreviewChunk> previewChunks=this.previewChunks;
  if (previewChunks != null) {
    this.performUploads(previewChunks);
    for (    PreviewChunk chunk : previewChunks) {
      chunk.render();
    }
  }
}

Fixed version (ground truth):
public void render(){
  List<PreviewChunk> previewChunks=this.previewChunks;
  if (previewChunks != null) {
    this.performUploads(previewChunks);
    for (    PreviewChunk chunk : previewChunks) {
      chunk.render(this.centerBlockPos.getX(),this.centerBlockPos.getZ());
    }
  }
}
Program: 175385
Project: 175385
Buggy source:
@SubscribeEvent public void onLivingTick(LivingUpdateEvent evt){
  if (!evt.getEntity().world.isRemote && evt.getEntityLiving() instanceof EntityPlayer) {
    EntityPlayer player=(EntityPlayer)evt.getEntityLiving();
    PlayerData data=player.getCapability(PlayerData.CAPABILITY,null);
    Fortune f=data.getFortune();
    if (f != null) {
      if (f.canShouldBeAppliedNow(player)) {
        if (f.apply(player))         data.setFortune(null);
      }
    }
  }
}

Fixed version (ground truth):
@SubscribeEvent public void onLivingTick(PlayerTickEvent evt){
  if (!evt.player.world.isRemote && evt.phase == Phase.END) {
    PlayerData data=evt.player.getCapability(PlayerData.CAPABILITY,null);
    Fortune f=data.getFortune();
    if (f != null) {
      if (f.canShouldBeAppliedNow(evt.player)) {
        if (f.apply(evt.player))         data.setFortune(null);
      }
    }
  }
}
Program: 175386
Project: 175386
Buggy source:
public boolean fortune(EntityPlayer reader){
  if (consumePower(1000,false)) {
    EntityLivingBase de=getDestinationEntity();
    if (de instanceof EntityPlayer)     return readFortune((EntityPlayer)de,reader);
 else     if (de == null && this.getDestinationPosition() == null)     return readFortune(reader,null);
 else {
      reader.sendStatusMessage(new TextComponentTranslation("String_Node_Str"),true);
      return false;
    }
  }
  reader.sendStatusMessage(new TextComponentTranslation("String_Node_Str"),true);
  return false;
}

Fixed version (ground truth):
public boolean fortune(EntityPlayer reader){
  if (consumePower(5000,false)) {
    EntityLivingBase de=getDestinationEntity();
    if (de instanceof EntityPlayer)     return readFortune((EntityPlayer)de,reader);
 else     if (de == null && this.getDestinationPosition() == null)     return readFortune(reader,null);
 else {
      reader.sendStatusMessage(new TextComponentTranslation("String_Node_Str"),true);
      return false;
    }
  }
  reader.sendStatusMessage(new TextComponentTranslation("String_Node_Str"),true);
  return false;
}
Program: 175387
Project: 175387
Buggy source:
private boolean readFortune(@Nonnull EntityPlayer endPlayer,@Nullable EntityPlayer externalReader){
  Fortune fortune=endPlayer.getCapability(PlayerData.CAPABILITY,null).getFortune();
  EntityPlayer messageRecpt=endPlayer;
  if (externalReader != null)   messageRecpt=externalReader;
  if (fortune != null) {
    messageRecpt.sendStatusMessage(new TextComponentTranslation("String_Node_Str",fortune.getLocalizedName(endPlayer)),true);
    return false;
  }
  List<Fortune> valid=Fortune.REGISTRY.getValues().parallelStream().filter(f -> f.canBeUsedFor(endPlayer)).collect(Collectors.toList());
  if (valid.size() == 0) {
    messageRecpt.sendStatusMessage(new TextComponentTranslation("String_Node_Str"),true);
    return false;
  }
  int totalEntries=valid.parallelStream().mapToInt(f -> f.getDrawingWeight()).sum();
  final int draw=endPlayer.getRNG().nextInt(totalEntries);
  int current=0;
  for (  Fortune f : valid) {
    int entries=f.getDrawingWeight();
    if (current < draw && draw < current + entries) {
      fortune=f;
      break;
    }
    current+=entries;
  }
  endPlayer.getCapability(PlayerData.CAPABILITY,null).setFortune(fortune);
  endPlayer.sendStatusMessage(new TextComponentString(fortune.getLocalizedName(endPlayer)),true);
  if (externalReader != null) {
    externalReader.sendStatusMessage(new TextComponentTranslation("String_Node_Str",fortune.getLocalizedName(endPlayer)),false);
    locator=ItemStack.EMPTY;
  }
  return true;
}

Fixed version (ground truth):
private boolean readFortune(@Nonnull EntityPlayer endPlayer,@Nullable EntityPlayer externalReader){
  EntityPlayer messageRecpt=endPlayer;
  if (externalReader != null)   messageRecpt=externalReader;
  if (endPlayer.getDistanceSq(this.getPos()) > 25) {
    messageRecpt.sendStatusMessage(new TextComponentTranslation("String_Node_Str"),true);
    return false;
  }
  Fortune fortune=endPlayer.getCapability(PlayerData.CAPABILITY,null).getFortune();
  if (fortune != null) {
    messageRecpt.sendStatusMessage(new TextComponentTranslation("String_Node_Str",fortune.getLocalizedName(endPlayer)),true);
    return false;
  }
  List<Fortune> valid=Fortune.REGISTRY.getValues().parallelStream().filter(f -> f.canBeUsedFor(endPlayer)).collect(Collectors.toList());
  if (valid.size() == 0) {
    messageRecpt.sendStatusMessage(new TextComponentTranslation("String_Node_Str"),true);
    return false;
  }
  int totalEntries=valid.parallelStream().mapToInt(f -> f.getDrawingWeight()).sum();
  final int draw=endPlayer.getRNG().nextInt(totalEntries);
  int current=0;
  for (  Fortune f : valid) {
    int entries=f.getDrawingWeight();
    if (current < draw && draw < current + entries) {
      fortune=f;
      break;
    }
    current+=entries;
  }
  endPlayer.getCapability(PlayerData.CAPABILITY,null).setFortune(fortune);
  endPlayer.sendStatusMessage(new TextComponentString(fortune.getLocalizedName(endPlayer)),true);
  if (externalReader != null) {
    externalReader.sendStatusMessage(new TextComponentTranslation("String_Node_Str",fortune.getLocalizedName(endPlayer)),false);
    locator=ItemStack.EMPTY;
  }
  return true;
}
Program: 175388
Project: 175388
Buggy source:
private boolean applyBrew(EntityPlayer thrower,ItemStack is){
  if (consumePower(4000,false)) {
    EntityLivingBase de=getDestinationEntity();
    Tuple<BlockPos,Integer> dp=getDestinationPosition();
    if (is.getItem() == ModItems.brew_drinkable) {
      if (de != null)       applyPotion(de,is);
 else       return false;
    }
 else     if (is.getItem() instanceof ItemBrewBase) {
      if (dp != null && this.world.provider.getDimension() == dp.getSecond().intValue()) {
        launchPotion(is,dp,thrower);
      }
    }
 else     return false;
    locator=ItemStack.EMPTY;
    markDirty();
    return true;
  }
  return false;
}

Fixed version (ground truth):
private boolean applyBrew(EntityPlayer thrower,ItemStack is){
  EntityLivingBase de=getDestinationEntity();
  Tuple<BlockPos,Integer> dp=getDestinationPosition();
  if (is.getItem() == ModItems.brew_drinkable) {
    if (de != null) {
      int cost=(int)(10 * de.getDistance(pos.getX(),pos.getY(),pos.getZ()));
      if (de.dimension != this.world.provider.getDimension())       return false;
      if (consumePower(cost,false))       applyPotionEffectsToEntity(de,is);
 else       return false;
    }
 else     return false;
  }
 else   if (is.getItem() instanceof ItemBrewBase) {
    if (dp != null && this.world.provider.getDimension() == dp.getSecond().intValue()) {
      int cost=(int)(50 * dp.getFirst().getDistance(pos.getX(),pos.getY(),pos.getZ()));
      if (consumePower(cost,false))       launchBrew(is,dp,thrower);
 else       return false;
    }
 else     return false;
  }
 else   return false;
  locator=ItemStack.EMPTY;
  markDirty();
  return true;
}
Program: 175389
Project: 175389
Buggy source:
private void initData(){
  mAddressList=getIntent().getParcelableArrayListExtra("String_Node_Str");
  if (mAddressList == null || mAddressList.size() == 0) {
    ToastUtil.toastInCenter(getApplicationContext(),R.string.broke_news_location_failed);
  }
  mSharedPrefUtil=SharedPrefUtil.getInstance(this);
  mLastTimeAddress=mSharedPrefUtil.getString(Constants.LOCATION_ADDRESS_SP_KEY);
  mLinearLayoutManager=new LinearLayoutManager(this);
  mAddressListAdapter=new AddressListAdapter(mAddressList,mLastTimeAddress);
}

Fixed version (ground truth):
private void initData(){
  mAddressList=getIntent().getParcelableArrayListExtra("String_Node_Str");
  if (!isLocated()) {
    ToastUtil.toastInCenter(getApplicationContext(),R.string.broke_news_location_failed);
  }
  mSharedPrefUtil=SharedPrefUtil.getInstance(this);
  mLastTimeAddress=mSharedPrefUtil.getString(Constants.LOCATION_ADDRESS_SP_KEY);
  mLinearLayoutManager=new LinearLayoutManager(this);
  mAddressListAdapter=new AddressListAdapter(mAddressList,mLastTimeAddress);
}
Program: 175390
Project: 175390
Buggy source:
@Override public void onClick(View v){
switch (v.getId()) {
case R.id.go_back_btn_address_list:
    Intent intent=new Intent();
  if (mLastTimeAddress != null) {
    if (mLastTimeAddress.equals("String_Node_Str")) {
      intent.putExtra("String_Node_Str","String_Node_Str");
    }
 else {
      intent.putExtra("String_Node_Str",mLastTimeAddress);
    }
  }
setResult(0,intent);
finish();
break;
}
}

Fixed version (ground truth):
@Override public void onClick(View v){
switch (v.getId()) {
case R.id.go_back_btn_address_list:
    Intent intent=new Intent();
  if (isLocated() && mLastTimeAddress != null) {
    if (mLastTimeAddress.equals("String_Node_Str")) {
      intent.putExtra("String_Node_Str","String_Node_Str");
    }
 else {
      intent.putExtra("String_Node_Str",mLastTimeAddress);
    }
  }
setResult(0,intent);
finish();
break;
}
}
Program: 175391
Project: 175391
Buggy source:
public void clearTask(){
  berkeleyDBSeedManager.clear();
}

Fixed version (ground truth):
public VSCrawler clearTask(){
  berkeleyDBSeedManager.clear();
  return this;
}
Program: 175392
Project: 175392
Buggy source:
public void pushSeed(String seed){
  berkeleyDBSeedManager.addNewSeeds(Lists.newArrayList(new Seed(seed)));
}

Fixed version (ground truth):
public VSCrawler pushSeed(String seed){
  berkeleyDBSeedManager.addNewSeeds(Lists.newArrayList(new Seed(seed)));
  return this;
}
Program: 175393
Project: 175393
Buggy source:
public AnnotationProcessorBuilder registryBean(Class<? extends AbstractAutoProcessModel> clazz){
  allExtractors.put(clazz,new ModelExtractor(clazz,this));
  AnnotationSeedProcessor.MatchStrategy matchStrategy=judgeMatchStrategy(clazz);
  if (matchStrategy != null) {
    annotationSeedProcessors.add(new AnnotationSeedProcessor(clazz,this,matchStrategy));
  }
  return this;
}

Fixed version (ground truth):
public AnnotationProcessorBuilder registryBean(Class<? extends AbstractAutoProcessModel> clazz){
  if (allExtractors.containsKey(clazz)) {
    return this;
  }
  allExtractors.put(clazz,new ModelExtractor(clazz,this));
  AnnotationSeedProcessor.MatchStrategy matchStrategy=judgeMatchStrategy(clazz);
  if (matchStrategy != null) {
    annotationSeedProcessors.add(new AnnotationSeedProcessor(clazz,this,matchStrategy));
  }
  return this;
}
Program: 175394
Project: 175394
Buggy source:
public SeedProcessor build(){
  scan();
  for (  ModelExtractor modelExtractor : allExtractors.values()) {
    modelExtractor.init();
  }
  RouteProcessor routeProcessor=new RouteProcessor();
  for (  AnnotationSeedProcessor annotationSeedProcessor : annotationSeedProcessors) {
    routeProcessor.addRouter(annotationSeedProcessor);
  }
  return routeProcessor;
}

Fixed version (ground truth):
public SeedProcessor build(){
  if (allExtractors.size() == 0 || scanPackage.size() > 0) {
    scan();
  }
  if (allExtractors.size() == 0) {
    throw new IllegalStateException("String_Node_Str");
  }
  for (  ModelExtractor modelExtractor : allExtractors.values()) {
    modelExtractor.init();
  }
  RouteProcessor routeProcessor=new RouteProcessor();
  for (  AnnotationSeedProcessor annotationSeedProcessor : annotationSeedProcessors) {
    routeProcessor.addRouter(annotationSeedProcessor);
  }
  return routeProcessor;
}
Program: 175396
Project: 175396
Buggy source:
@Override public XpathNode convert(final StringNode from){
  XpathNode ret=new XpathNode(from.getBaseUrl(),null);
  ret.setModel(new SipNodes(Lists.newLinkedList(Iterables.transform(from.createOrGetModel(),new Function<String,SIPNode>(){
    @Override public SIPNode apply(    String input){
      try {
        Document document=Jsoup.parse(input,from.getBaseUrl());
        if (document != null) {
          return SIPNode.e(document);
        }
      }
 catch (      Exception e) {
      }
      return SIPNode.t(input);
    }
  }
))));
  return ret;
}

Fixed version (ground truth):
@Override public XpathNode convert(final StringNode from){
  XpathNode ret=new XpathNode(from.getBaseUrl(),(String)null);
  ret.setModel(new SipNodes(Lists.newLinkedList(Iterables.transform(from.createOrGetModel(),new Function<String,SIPNode>(){
    @Override public SIPNode apply(    String input){
      try {
        Document document=Jsoup.parse(input,from.getBaseUrl());
        if (document != null) {
          return SIPNode.e(document);
        }
      }
 catch (      Exception e) {
      }
      return SIPNode.t(input);
    }
  }
))));
  return ret;
}
Program: 175397
Project: 175397
Buggy source:
private static void registerXpath(){
  register(XpathNode.class,XpathNode.class,new NodeConvert<XpathNode,XpathNode>(){
    @Override public XpathNode convert(    XpathNode from){
      return from;
    }
  }
);
  register(JsonNode.class,XpathNode.class,new NodeConvert<JsonNode,XpathNode>(){
    @Override public XpathNode convert(    JsonNode from){
      throw new UnsupportedOperationException("String_Node_Str");
    }
  }
);
  register(RawNode.class,XpathNode.class,new NodeConvert<RawNode,XpathNode>(){
    @Override public XpathNode convert(    RawNode from){
      return new XpathNode(from.getBaseUrl(),from.getRawText());
    }
  }
);
  register(StringNode.class,XpathNode.class,new NodeConvert<StringNode,XpathNode>(){
    @Override public XpathNode convert(    final StringNode from){
      XpathNode ret=new XpathNode(from.getBaseUrl(),null);
      ret.setModel(new SipNodes(Lists.newLinkedList(Iterables.transform(from.createOrGetModel(),new Function<String,SIPNode>(){
        @Override public SIPNode apply(        String input){
          try {
            Document document=Jsoup.parse(input,from.getBaseUrl());
            if (document != null) {
              return SIPNode.e(document);
            }
          }
 catch (          Exception e) {
          }
          return SIPNode.t(input);
        }
      }
))));
      return ret;
    }
  }
);
}

Fixed version (ground truth):
private static void registerXpath(){
  register(XpathNode.class,XpathNode.class,new NodeConvert<XpathNode,XpathNode>(){
    @Override public XpathNode convert(    XpathNode from){
      return from;
    }
  }
);
  register(JsonNode.class,XpathNode.class,new NodeConvert<JsonNode,XpathNode>(){
    @Override public XpathNode convert(    JsonNode from){
      throw new UnsupportedOperationException("String_Node_Str");
    }
  }
);
  register(RawNode.class,XpathNode.class,new NodeConvert<RawNode,XpathNode>(){
    @Override public XpathNode convert(    RawNode from){
      return new XpathNode(from.getBaseUrl(),from.getRawText());
    }
  }
);
  register(StringNode.class,XpathNode.class,new NodeConvert<StringNode,XpathNode>(){
    @Override public XpathNode convert(    final StringNode from){
      XpathNode ret=new XpathNode(from.getBaseUrl(),(String)null);
      ret.setModel(new SipNodes(Lists.newLinkedList(Iterables.transform(from.createOrGetModel(),new Function<String,SIPNode>(){
        @Override public SIPNode apply(        String input){
          try {
            Document document=Jsoup.parse(input,from.getBaseUrl());
            if (document != null) {
              return SIPNode.e(document);
            }
          }
 catch (          Exception e) {
          }
          return SIPNode.t(input);
        }
      }
))));
      return ret;
    }
  }
);
}
Program: 175398
Project: 175398
Buggy source:
private static void registerJson(){
  register(JsonNode.class,JsonNode.class,new NodeConvert<JsonNode,JsonNode>(){
    @Override public JsonNode convert(    JsonNode from){
      return from;
    }
  }
);
  register(RawNode.class,JsonNode.class,new NodeConvert<RawNode,JsonNode>(){
    @Override public JsonNode convert(    RawNode from){
      return new JsonNode(from.getBaseUrl(),from.getRawText());
    }
  }
);
  register(StringNode.class,JsonNode.class,new NodeConvert<StringNode,JsonNode>(){
    @Override public JsonNode convert(    StringNode from){
      JsonNode jsonNode=new JsonNode(from.getBaseUrl(),null);
      jsonNode.setModel(Lists.transform(from.createOrGetModel(),new Function<String,JSON>(){
        @Override public JSON apply(        String input){
          return (JSON)JSON.parse(input);
        }
      }
));
      return jsonNode;
    }
  }
);
  register(XpathNode.class,JsonNode.class,new NodeConvert<XpathNode,JsonNode>(){
    @Override public JsonNode convert(    XpathNode from){
      JsonNode ret=new JsonNode(from.getBaseUrl(),null);
      ret.setModel(Lists.newLinkedList(Iterables.transform(Iterables.filter(from.createOrGetModel(),new Predicate<SIPNode>(){
        @Override public boolean apply(        SIPNode input){
          return input.isText();
        }
      }
),new Function<SIPNode,JSON>(){
        @Override public JSON apply(        SIPNode input){
          return (JSON)JSON.parse(input.getTextVal());
        }
      }
)));
      return ret;
    }
  }
);
}

Fixed version (ground truth):
private static void registerJson(){
  register(JsonNode.class,JsonNode.class,new NodeConvert<JsonNode,JsonNode>(){
    @Override public JsonNode convert(    JsonNode from){
      return from;
    }
  }
);
  register(RawNode.class,JsonNode.class,new NodeConvert<RawNode,JsonNode>(){
    @Override public JsonNode convert(    RawNode from){
      return new JsonNode(from.getBaseUrl(),from.getRawText());
    }
  }
);
  register(StringNode.class,JsonNode.class,new NodeConvert<StringNode,JsonNode>(){
    @Override public JsonNode convert(    StringNode from){
      JsonNode jsonNode=new JsonNode(from.getBaseUrl(),(String)null);
      jsonNode.setModel(Lists.transform(from.createOrGetModel(),new Function<String,JSON>(){
        @Override public JSON apply(        String input){
          return (JSON)JSON.parse(input);
        }
      }
));
      return jsonNode;
    }
  }
);
  register(XpathNode.class,JsonNode.class,new NodeConvert<XpathNode,JsonNode>(){
    @Override public JsonNode convert(    XpathNode from){
      JsonNode ret=new JsonNode(from.getBaseUrl(),(String)null);
      ret.setModel(Lists.newLinkedList(Iterables.transform(Iterables.filter(from.createOrGetModel(),new Predicate<SIPNode>(){
        @Override public boolean apply(        SIPNode input){
          return input.isText();
        }
      }
),new Function<SIPNode,JSON>(){
        @Override public JSON apply(        SIPNode input){
          return (JSON)JSON.parse(input.getTextVal());
        }
      }
)));
      return ret;
    }
  }
);
}
Program: 175399
Project: 175399
Buggy source:
public VSCrawlerBuilder addRouteProcessor(SeedRouter seedRouter){
  this.seedRouters.add(seedRouter);
  return this;
}

Fixed version (ground truth):
public VSCrawlerBuilder addRouteProcessor(BindRouteProcessor seedRouter){
  this.seedRouters.add(seedRouter);
  return this;
}
Program: 175400
Project: 175400
Buggy source:
@Override public void onSessionCreateEvent(CrawlerSession crawlerSession){
  if (!crawlerSession.isValid()) {
    return;
  }
  User user;
  while (true) {
    if ((user=userManager.allocateUser()) != null) {
      break;
    }
    CommonUtil.sleep(5000);
  }
  boolean loginSuccess=loginHandler.onLogin(user,crawlerSession.getCookieStore(),crawlerSession.getCrawlerHttpClient());
  if (loginSuccess) {
    UserUtil.setUser(crawlerSession,user);
  }
 else {
    userManager.returnUser(user);
    log.warn("String_Node_Str",user);
  }
}

Fixed version (ground truth):
@Override public void onSessionCreateEvent(CrawlerSession crawlerSession){
  if (!crawlerSession.isValid()) {
    return;
  }
  User user;
  while (true) {
    if ((user=userManager.allocateUser()) != null) {
      break;
    }
    CommonUtil.sleep(5000);
  }
  boolean loginSuccess=loginHandler.onLogin(user,crawlerSession.getCookieStore(),crawlerSession.getCrawlerHttpClient());
  if (loginSuccess) {
    UserUtil.setUser(crawlerSession,user);
  }
 else {
    userManager.returnUser(user);
    log.warn("String_Node_Str",JSONObject.toJSONString(user));
  }
}
Program: 175401
Project: 175401
Buggy source:
@Override public void configChange(Properties oldProperties,Properties newProperties){
  String property=newProperties.getProperty(VSCrawlerConstant.USER_RESOURCE_USERINFO);
  hasConfig=property != null;
  if (property == null) {
    crawlerThreadNumber=NumberUtils.toInt(newProperties.getProperty(VSCrawlerConstant.VSCRAWLER_THREAD_NUMBER));
    return;
  }
  if (!property.equals(oldProperties.getProperty(VSCrawlerConstant.USER_RESOURCE_USERINFO))) {
    List<String> allUser=userSplitter.splitToList(property);
    int newUserNum=0;
    for (    String userStr : allUser) {
      User user=new User();
      List<String> strings=userItemSplitter.splitToList(userStr);
      if (strings.size() < 2) {
        log.warn("String_Node_Str",userStr);
        continue;
      }
      user.setUserID(strings.get(0));
      user.setPassword(strings.get(1));
      if (strings.size() >= 3) {
        String status=strings.get(2);
        if (StringUtils.equalsIgnoreCase(status,"String_Node_Str")) {
          AutoEventRegistry.getInstance().findEventDeclaring(UserStateChangeEvent.class).userStatusChange(user,UserStatus.UNKNOWN,UserStatus.FORBID);
          continue;
        }
      }
      user.setUserStatus(UserStatus.INIT);
      userCache.add(user);
      newUserNum++;
    }
    log.info("String_Node_Str",newUserNum);
  }
}

Fixed version (ground truth):
@Override public void configChange(Properties oldProperties,Properties newProperties){
  String property=newProperties.getProperty(VSCrawlerConstant.USER_RESOURCE_USERINFO);
  hasConfig=property != null;
  if (property == null) {
    crawlerThreadNumber=NumberUtils.toInt(newProperties.getProperty(VSCrawlerConstant.VSCRAWLER_THREAD_NUMBER));
    return;
  }
  if (oldProperties != null && property.equals(oldProperties.getProperty(VSCrawlerConstant.USER_RESOURCE_USERINFO))) {
    return;
  }
  List<String> allUser=userSplitter.splitToList(property);
  int newUserNum=0;
  for (  String userStr : allUser) {
    User user=new User();
    List<String> strings=userItemSplitter.splitToList(userStr);
    if (strings.size() < 2) {
      log.warn("String_Node_Str",userStr);
      continue;
    }
    user.setUserID(strings.get(0));
    user.setPassword(strings.get(1));
    if (strings.size() >= 3) {
      String status=strings.get(2);
      if (StringUtils.equalsIgnoreCase(status,"String_Node_Str")) {
        AutoEventRegistry.getInstance().findEventDeclaring(UserStateChangeEvent.class).userStatusChange(user,UserStatus.UNKNOWN,UserStatus.FORBID);
        continue;
      }
    }
    user.setUserStatus(UserStatus.INIT);
    userCache.add(user);
    newUserNum++;
  }
  log.info("String_Node_Str",newUserNum);
}
Program: 175402
Project: 175402
Buggy source:
public FilePipLine(String filepath) throws FileNotFoundException {
  this.filepath=filepath;
  printWriter=new PrintWriter(new FileOutputStream(new File(filepath)));
}

Fixed version (ground truth):
public FilePipLine(String filepath) throws FileNotFoundException {
  this.filepath=filepath;
  printWriter=new PrintWriter(new FileOutputStream(new File(filepath),true));
}
Program: 175403
Project: 175403
Buggy source:
private static void registerJson(){
  register(JsonNode.class,JsonNode.class,new NodeConvert<JsonNode,JsonNode>(){
    @Override public JsonNode convert(    JsonNode from){
      return from;
    }
  }
);
  register(RawNode.class,JsonNode.class,new NodeConvert<RawNode,JsonNode>(){
    @Override public JsonNode convert(    RawNode from){
      return new JsonNode(from.getBaseUrl(),from.getRawText());
    }
  }
);
  register(StringNode.class,JsonNode.class,new NodeConvert<StringNode,JsonNode>(){
    @Override public JsonNode convert(    StringNode from){
      JsonNode jsonNode=new JsonNode(from.getBaseUrl(),null);
      jsonNode.setModel(Lists.transform(from.createOrGetModel(),new Function<String,JSON>(){
        @Override public JSON apply(        String input){
          return (JSON)JSON.toJSON(input);
        }
      }
));
      return jsonNode;
    }
  }
);
  register(XpathNode.class,JsonNode.class,new NodeConvert<XpathNode,JsonNode>(){
    @Override public JsonNode convert(    XpathNode from){
      JsonNode ret=new JsonNode(from.getBaseUrl(),null);
      ret.setModel(Lists.newLinkedList(Iterables.transform(Iterables.filter(from.createOrGetModel(),new Predicate<SIPNode>(){
        @Override public boolean apply(        SIPNode input){
          return input.isText();
        }
      }
),new Function<SIPNode,JSON>(){
        @Override public JSON apply(        SIPNode input){
          return (JSON)JSON.parse(input.getTextVal());
        }
      }
)));
      return ret;
    }
  }
);
}

Fixed version (ground truth):
private static void registerJson(){
  register(JsonNode.class,JsonNode.class,new NodeConvert<JsonNode,JsonNode>(){
    @Override public JsonNode convert(    JsonNode from){
      return from;
    }
  }
);
  register(RawNode.class,JsonNode.class,new NodeConvert<RawNode,JsonNode>(){
    @Override public JsonNode convert(    RawNode from){
      return new JsonNode(from.getBaseUrl(),from.getRawText());
    }
  }
);
  register(StringNode.class,JsonNode.class,new NodeConvert<StringNode,JsonNode>(){
    @Override public JsonNode convert(    StringNode from){
      JsonNode jsonNode=new JsonNode(from.getBaseUrl(),null);
      jsonNode.setModel(Lists.transform(from.createOrGetModel(),new Function<String,JSON>(){
        @Override public JSON apply(        String input){
          return (JSON)JSON.parse(input);
        }
      }
));
      return jsonNode;
    }
  }
);
  register(XpathNode.class,JsonNode.class,new NodeConvert<XpathNode,JsonNode>(){
    @Override public JsonNode convert(    XpathNode from){
      JsonNode ret=new JsonNode(from.getBaseUrl(),null);
      ret.setModel(Lists.newLinkedList(Iterables.transform(Iterables.filter(from.createOrGetModel(),new Predicate<SIPNode>(){
        @Override public boolean apply(        SIPNode input){
          return input.isText();
        }
      }
),new Function<SIPNode,JSON>(){
        @Override public JSON apply(        SIPNode input){
          return (JSON)JSON.parse(input.getTextVal());
        }
      }
)));
      return ret;
    }
  }
);
}
Program: 175404
Project: 175404
Buggy source:
private SyntaxNode parseFunction(StringFunctionTokenQueue tokenQueue){
  String functionString=tokenQueue.consumeFunction();
  StringFunctionTokenQueue tempTokenQueue=new StringFunctionTokenQueue(functionString);
  String functionName=tempTokenQueue.consumeIdentify();
  StringFunction function=StringFunctionEnv.findFunction(functionName);
  if (function == null) {
    throw new IllegalStateException("String_Node_Str" + functionName);
  }
  tempTokenQueue.consumeWhitespace();
  if (tempTokenQueue.isEmpty() || tempTokenQueue.peek() != '(') {
    throw new IllegalStateException("String_Node_Str" + functionString + "String_Node_Str");
  }
  String paramsStr=tempTokenQueue.chompBalanced('(',')');
  StringFunctionTokenQueue paramTokenQueue=new StringFunctionTokenQueue(paramsStr);
  String parameter;
  List<SyntaxNode> params=Lists.newLinkedList();
  while ((parameter=paramTokenQueue.consumeIgnoreQuote(',')) != null) {
    params.add(new ExpressionParser(new StringFunctionTokenQueue(parameter)).parse());
  }
  return new FunctionSyntaxNode(function,params);
}

Fixed version (ground truth):
private SyntaxNode parseFunction(StringFunctionTokenQueue tokenQueue){
  String functionString=tokenQueue.consumeFunction();
  StringFunctionTokenQueue tempTokenQueue=new StringFunctionTokenQueue(functionString);
  String functionName=tempTokenQueue.consumeIdentify();
  StringFunction function=StringFunctionEnv.findFunction(functionName);
  if (function == null) {
    throw new IllegalStateException("String_Node_Str" + functionName);
  }
  tempTokenQueue.consumeWhitespace();
  if (tempTokenQueue.isEmpty() || tempTokenQueue.peek() != '(') {
    throw new IllegalStateException("String_Node_Str" + functionString + "String_Node_Str");
  }
  String paramsStr=StringUtils.trimToEmpty(tempTokenQueue.chompBalanced('(',')'));
  StringFunctionTokenQueue paramTokenQueue=new StringFunctionTokenQueue(paramsStr);
  String parameter;
  List<SyntaxNode> params=Lists.newLinkedList();
  while ((parameter=paramTokenQueue.consumeIgnoreQuote(',')) != null) {
    params.add(new ExpressionParser(new StringFunctionTokenQueue(parameter)).parse());
  }
  paramTokenQueue.consumeWhitespace();
  if (!paramTokenQueue.isEmpty()) {
    params.add(new ExpressionParser(new StringFunctionTokenQueue(paramTokenQueue.remainder())).parse());
  }
  return new FunctionSyntaxNode(function,params);
}
Program: 175405
Project: 175405
Buggy source:
public String consumeFunction(){
  String functionName=consumeTo("String_Node_Str");
  String params=chompBalanced('(',')');
  return functionName + "String_Node_Str" + params+ "String_Node_Str";
}

Fixed version (ground truth):
public String consumeFunction(){
  String functionName=consumeTo("String_Node_Str");
  String params=chompBalanced('(',')');
  return functionName + "String_Node_Str" + (params == null ? "String_Node_Str" : params)+ "String_Node_Str";
}
Program: 175406
Project: 175406
Buggy source:
static public PImage createSprite(PApplet papplet,int size,float exp1,float exp2,float mult){
  size=Math.max(32,size);
  PImage pimg=papplet.createImage(size,size,PConstants.ARGB);
  pimg.loadPixels();
  for (int y=0; y < size; y++) {
    for (int x=0; x < size; x++) {
      int pid=y * size + x;
      float xn=(x / (float)size) * 2f - 1f;
      float yn=(y / (float)size) * 2f - 1f;
      float dd=(float)Math.sqrt(xn * xn + yn * yn);
      if (dd < 0)       dd=0;
 else       if (dd > 1)       dd=1;
      dd=(float)Math.pow(dd,exp1);
      dd=1.0f - dd;
      dd=(float)Math.pow(dd,exp2);
      dd*=mult;
      pimg.pixels[pid]=((int)(dd * 255)) << 24 | 0x00FFFFFF;
    }
  }
  pimg.updatePixels();
  return pimg;
}

Fixed version (ground truth):
static public PImage createSprite(PApplet papplet,int size,float exp1,float exp2,float mult){
  size=Math.max(32,size);
  PImage pimg=papplet.createImage(size,size,PConstants.ARGB);
  pimg.loadPixels();
  for (int y=0; y < size; y++) {
    for (int x=0; x < size; x++) {
      int pid=y * size + x;
      float xn=(x / (float)size) * 2f - 1f;
      float yn=(y / (float)size) * 2f - 1f;
      float dd=(float)Math.sqrt(xn * xn + yn * yn);
      dd=DwUtils.clamp(dd,0,1);
      dd=(float)Math.pow(dd,exp1);
      dd=1.0f - dd;
      dd=(float)Math.pow(dd,exp2);
      dd*=mult;
      dd=DwUtils.clamp(dd,0,1);
      pimg.pixels[pid]=((int)(dd * 255)) << 24 | 0x00FFFFFF;
    }
  }
  pimg.updatePixels();
  return pimg;
}
Program: 175407
Project: 175407
Buggy source:
@Override public boolean reportFixture(Fixture argFixture){
  Body body=argFixture.getBody();
  body_type_cpy=body.getType();
  if (enable_static_drag) {
    body.setType(BodyType.DYNAMIC);
  }
  if (body.getType() == BodyType.DYNAMIC) {
    if (argFixture.testPoint(point)) {
      fixture=argFixture;
      return false;
    }
  }
  return true;
}

Fixed version (ground truth):
@Override public boolean reportFixture(Fixture argFixture){
  Body body=argFixture.getBody();
  BodyType type=body.getType();
  if (BodyType.DYNAMIC == type || enable_static_drag) {
    if (argFixture.testPoint(point)) {
      body_type_cpy=type;
      fixture=argFixture;
      body.setType(BodyType.DYNAMIC);
      return false;
    }
  }
  return true;
}
Program: 175408
Project: 175408
Buggy source:
@Test public void testLoaderIsFound() throws ClassNotFoundException, IOException, IllegalAccessException, InstantiationException, JAXBException {
  String pathToLocalJar=System.getProperty("String_Node_Str");
  JarScanner collectorFinder=new JarScanner(ClassLoader.getSystemClassLoader(),pathToLocalJar);
  collectorFinder.scanJar();
  MonitorStatusCollectorLoader loader=collectorFinder.getStatusCollectorLoader();
  Assert.assertNotNull(loader);
}

Fixed version (ground truth):
@Test(enabled=false) public void testLoaderIsFound() throws ClassNotFoundException, IOException, IllegalAccessException, InstantiationException, JAXBException {
  String pathToLocalJar=System.getProperty("String_Node_Str");
  JarScanner collectorFinder=new JarScanner(ClassLoader.getSystemClassLoader(),pathToLocalJar);
  collectorFinder.scanJar();
  MonitorStatusCollectorLoader loader=collectorFinder.getStatusCollectorLoader();
  Assert.assertNotNull(loader);
}
Program: 175409
Project: 175409
Buggy source:
/** 
 * @return a new map with the names and values provided as fileInfo when the file was uploaded.
 * @apiNote the map may be empty, but it will never be null.
 */
default Map<String,String> getB2FileInfo(){
  final Map<String,String> info=new TreeMap<>();
  for (  String name : getNames()) {
    if (startsWithIgnoreCase(name,FILE_INFO_PREFIX)) {
      final String shortName=name.substring(FILE_INFO_PREFIX.length());
      info.put(shortName,getValueOrNull(name));
    }
  }
  return info;
}

Fixed version (ground truth):
/** 
 * @return a new map with the names and values provided as fileInfo when the file was uploaded.
 * @apiNote the map may be empty, but it will never be null.
 */
default Map<String,String> getB2FileInfo(){
  final Map<String,String> info=new TreeMap<>();
  for (  String name : getNames()) {
    if (startsWithIgnoreCase(name,FILE_INFO_PREFIX)) {
      final String shortName=name.substring(FILE_INFO_PREFIX.length());
      info.put(percentDecode(shortName),percentDecode(getValueOrNull(name)));
    }
  }
  return info;
}
Program: 175410
Project: 175410
Buggy source:
@Test public void testGetFileInfoByName() throws B2Exception {
  final B2GetFileInfoByNameRequest request=B2GetFileInfoByNameRequest.builder(bucketName(1),fileName(1)).build();
  B2FileVersion version=webifier.getFileInfoByName(ACCOUNT_AUTH,request);
  assertEquals(fileId(1),version.getFileId());
  assertEquals(fileName(1),version.getFileName());
  assertEquals(1L,version.getContentLength());
  assertEquals(1L,version.getUploadTimestamp());
  assertEquals(1L,Long.parseLong(version.getFileInfo().get(B2Headers.SRC_LAST_MODIFIED_MILLIS)));
  webApiClient.check("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str");
  checkRequestCategory(OTHER,w -> w.getFileInfoByName(ACCOUNT_AUTH,request));
}

Fixed version (ground truth):
@Test public void testGetFileInfoByName() throws B2Exception {
  final B2GetFileInfoByNameRequest request=B2GetFileInfoByNameRequest.builder(bucketName(1),fileName(1)).build();
  B2FileVersion version=webifier.getFileInfoByName(ACCOUNT_AUTH,request);
  Map<String,String> expectedFileInfo=new HashMap<>();
  expectedFileInfo.put("String_Node_Str","String_Node_Str");
  expectedFileInfo.put("String_Node_Str","String_Node_Str");
  assertEquals(fileId(1),version.getFileId());
  assertEquals(fileName(1),version.getFileName());
  assertEquals(1L,version.getContentLength());
  assertEquals(1L,version.getUploadTimestamp());
  assertEquals(expectedFileInfo,version.getFileInfo());
  assertEquals(1L,Long.parseLong(version.getFileInfo().get("String_Node_Str")));
  webApiClient.check("String_Node_Str" + "String_Node_Str" + "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str"+ "String_Node_Str");
  checkRequestCategory(OTHER,w -> w.getFileInfoByName(ACCOUNT_AUTH,request));
}
Program: 175411
Project: 175411
Buggy source:
public static B2Headers makeFileHeaders(int i){
  return B2HeadersImpl.builder().set(FILE_ID,fileId(i)).set(FILE_NAME,percentEncode(fileName(i))).set(CONTENT_LENGTH,Integer.toString(i)).set(UPLOAD_TIMESTAMP,Integer.toString(i)).set(FILE_INFO_PREFIX + SRC_LAST_MODIFIED_MILLIS,Integer.toString(i)).build();
}

Fixed version (ground truth):
public static B2Headers makeFileHeaders(int i){
  return B2HeadersImpl.builder().set(FILE_ID,fileId(i)).set(FILE_NAME,percentEncode(fileName(i))).set(CONTENT_LENGTH,Integer.toString(i)).set(UPLOAD_TIMESTAMP,Integer.toString(i)).set(SRC_LAST_MODIFIED_MILLIS,Integer.toString(i)).set(FILE_INFO_PREFIX + "String_Node_Str","String_Node_Str").build();
}
Program: 175412
Project: 175412
Buggy source:
@Override public B2FileVersion getFileInfoByName(B2AccountAuthorization accountAuth,B2GetFileInfoByNameRequest request) throws B2Exception {
  B2Headers headers=webApiClient.head(makeGetFileInfoByNameUrl(accountAuth,request.getBucketName(),request.getFileName()),makeHeaders(accountAuth));
  return new B2FileVersion(headers.getValueOrNull(FILE_ID),headers.getValueOrNull(FILE_NAME),headers.getContentLength(),headers.getContentType(),headers.getContentSha1OrNull(),headers.getB2FileInfo(),"String_Node_Str",Long.parseLong(headers.getValueOrNull(UPLOAD_TIMESTAMP)));
}

Fixed version (ground truth):
@Override public B2FileVersion getFileInfoByName(B2AccountAuthorization accountAuth,B2GetFileInfoByNameRequest request) throws B2Exception {
  B2Headers headers=webApiClient.head(makeGetFileInfoByNameUrl(accountAuth,request.getBucketName(),request.getFileName()),makeHeaders(accountAuth));
  return new B2FileVersion(headers.getValueOrNull(FILE_ID),percentDecode(headers.getValueOrNull(FILE_NAME)),headers.getContentLength(),headers.getContentType(),headers.getContentSha1OrNull(),headers.getB2FileInfo(),"String_Node_Str",Long.parseLong(headers.getValueOrNull(UPLOAD_TIMESTAMP)));
}
Program: 175413
Project: 175413
Buggy source:
public static B2Headers makeFileHeaders(int i){
  return B2HeadersImpl.builder().set(FILE_ID,fileId(i)).set(FILE_NAME,fileName(i)).set(CONTENT_LENGTH,Integer.toString(i)).set(UPLOAD_TIMESTAMP,Integer.toString(i)).set(FILE_INFO_PREFIX + SRC_LAST_MODIFIED_MILLIS,Integer.toString(i)).build();
}

Fixed version (ground truth):
public static B2Headers makeFileHeaders(int i){
  return B2HeadersImpl.builder().set(FILE_ID,fileId(i)).set(FILE_NAME,percentEncode(fileName(i))).set(CONTENT_LENGTH,Integer.toString(i)).set(UPLOAD_TIMESTAMP,Integer.toString(i)).set(FILE_INFO_PREFIX + SRC_LAST_MODIFIED_MILLIS,Integer.toString(i)).build();
}
Program: 175414
Project: 175414
Buggy source:
public Builder(B2ListUnfinishedLargeFilesRequest orig){
  this.bucketId=orig.bucketId;
  this.startFileId=orig.startFileId;
  this.maxFileCount=orig.maxFileCount;
}

Fixed version (ground truth):
public Builder(B2ListUnfinishedLargeFilesRequest orig){
  this.bucketId=orig.bucketId;
  this.namePrefix=orig.namePrefix;
  this.startFileId=orig.startFileId;
  this.maxFileCount=orig.maxFileCount;
}
Program: 175415
Project: 175415
Buggy source:
private void changeDarkTheme(boolean isDarkThemeEnabled){
  mTinyDB.putBoolean(getString(R.string.dark_theme_pref),isDarkThemeEnabled);
  recreate();
}

Fixed version (ground truth):
private void changeDarkTheme(boolean isDarkThemeEnabled){
  mTinyDB.putBoolean(getString(R.string.dark_theme_pref),isDarkThemeEnabled);
  Intent intent=getIntent();
  finish();
  startActivity(intent);
}
Program: 175416
Project: 175416
Buggy source:
public MyViewHolder(View view){
  super(view);
  txtView=(TextView)view.findViewById(R.id.txtView);
  tabTag=(TextView)view.findViewById(R.id.tabTag);
  priorityTag=view.findViewById(R.id.priorityTag);
}

Fixed version (ground truth):
MyViewHolder(View view){
  super(view);
  txtView=(TextView)view.findViewById(R.id.txtView);
  tabTag=(TextView)view.findViewById(R.id.tabTag);
  priorityTag=view.findViewById(R.id.priorityTag);
}
Program: 175417
Project: 175417
Buggy source:
public void setIdeaText(String ideaText){
  mIdea=ideaText;
}

Fixed version (ground truth):
void setIdeaText(String ideaText){
  mIdea=ideaText;
}
Program: 175418
Project: 175418
Buggy source:
public void setLongClickListener(View.OnLongClickListener l){
  mListener=l;
}

Fixed version (ground truth):
void setLongClickListener(View.OnLongClickListener l){
  mListener=l;
}
Program: 175421
Project: 175421
Buggy source:
public RecyclerOnClickListener(MyRecyclerView recyclerView,int tabNumber){
  mRecyclerView=recyclerView;
  mTabNumber=tabNumber;
}

Fixed version (ground truth):
public RecyclerOnClickListener(MyRecyclerView recyclerView,int tabNumber){
  this.context=recyclerView.getContext();
  mRecyclerView=recyclerView;
  mTabNumber=tabNumber;
  mDbHelper=DatabaseHelper.getInstance(context);
  TinyDB mTinyDB=new TinyDB(context);
  mDarkTheme=mTinyDB.getBoolean(context.getString(R.string.dark_theme_pref),false);
}