nus-yam/ex-repair huggingface dataset:
Program: 174662
Project: 174662
Buggy source:
public ItemMoonlitRod(String name,double baseDamage,double attackSpeed,int manaPerUse,int durability){
  super(name,baseDamage,attackSpeed,manaPerUse,durability);
}

Fixed version (ground truth):
public ItemMoonlitRod(String name,boolean isStaff,double baseDamage,double attackSpeed,int manaPerUse,int durability){
  super(name,isStaff,baseDamage,attackSpeed,manaPerUse,durability);
}
Program: 174663
Project: 174663
Buggy source:
public ItemVisageOfWizardry(String name,double baseDamage,double attackSpeed,int manaPerUse,int durability){
  super(name,baseDamage,attackSpeed,manaPerUse,durability);
}

Fixed version (ground truth):
public ItemVisageOfWizardry(String name,boolean isStaff,double baseDamage,double attackSpeed,int manaPerUse,int durability){
  super(name,isStaff,baseDamage,attackSpeed,manaPerUse,durability);
}
Program: 174664
Project: 174664
Buggy source:
@Override public Multimap<String,AttributeModifier> getAttributeModifiers(EntityEquipmentSlot slot,ItemStack stack){
  final Multimap<String,AttributeModifier> modifiers=super.getAttributeModifiers(slot,stack);
  if (slot == EntityEquipmentSlot.MAINHAND) {
    replaceModifier(modifiers,SharedMonsterAttributes.ATTACK_DAMAGE,ATTACK_DAMAGE_MODIFIER,damageMultiplier);
    replaceModifier(modifiers,SharedMonsterAttributes.ATTACK_SPEED,ATTACK_SPEED_MODIFIER,speedMultiplier);
  }
  if (speedMultiplier < 1)   NBTHelper.loadStackNBT(stack).setString("String_Node_Str","String_Node_Str");
 else   NBTHelper.loadStackNBT(stack).setString("String_Node_Str","String_Node_Str");
  return modifiers;
}

Fixed version (ground truth):
@Override public Multimap<String,AttributeModifier> getAttributeModifiers(EntityEquipmentSlot slot,ItemStack stack){
  final Multimap<String,AttributeModifier> modifiers=super.getAttributeModifiers(slot,stack);
  if (slot == EntityEquipmentSlot.MAINHAND) {
    replaceModifier(modifiers,SharedMonsterAttributes.ATTACK_DAMAGE,ATTACK_DAMAGE_MODIFIER,damageMultiplier);
    replaceModifier(modifiers,SharedMonsterAttributes.ATTACK_SPEED,ATTACK_SPEED_MODIFIER,speedMultiplier);
  }
  return modifiers;
}
Program: 174665
Project: 174665
Buggy source:
public ItemLEAdvancedMelee(ToolMaterial material,String name,double damageMultiplier,double speedMultiplier){
  super(material,name);
  this.damageMultiplier=damageMultiplier;
  this.speedMultiplier=speedMultiplier;
}

Fixed version (ground truth):
public ItemLEAdvancedMelee(ToolMaterial material,String name,String type,double damageMultiplier,double speedMultiplier){
  super(material,name,type);
  this.damageMultiplier=damageMultiplier;
  this.speedMultiplier=speedMultiplier;
}
Program: 174666
Project: 174666
Buggy source:
public ItemLEMelee(ToolMaterial material,String name,CreativeTabs tab){
  super(material);
  this.setRegistryName(Reference.MODID,name);
  this.setUnlocalizedName(name);
  this.setCreativeTab(tab);
}

Fixed version (ground truth):
public ItemLEMelee(ToolMaterial material,String name,String type,CreativeTabs tab){
  super(material);
  this.setRegistryName(Reference.MODID,name);
  this.setUnlocalizedName(name);
  this.setCreativeTab(tab);
  this.type=type;
}
Program: 174667
Project: 174667
Buggy source:
public ItemAlakaslam(ToolMaterial material,String name,double damageMultiplier,double speedMultiplier){
  super(material,name,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemAlakaslam(ToolMaterial material,String name,String type,double damageMultiplier,double speedMultiplier){
  super(material,name,type,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174668
Project: 174668
Buggy source:
public ItemAnnihilation(ToolMaterial material,String name,double damageMultiplier,double speedMultiplier){
  super(material,name,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemAnnihilation(ToolMaterial material,String name,String type,double damageMultiplier,double speedMultiplier){
  super(material,name,type,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174669
Project: 174669
Buggy source:
public ItemDivineRapier(ToolMaterial material,String name){
  super(material,name);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemDivineRapier(ToolMaterial material,String name,String type){
  super(material,name,type);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174670
Project: 174670
Buggy source:
public ItemDoomshadow(ToolMaterial material,String name,double damageMultiplier,double speedMultiplier){
  super(material,name,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemDoomshadow(ToolMaterial material,String name,String type,double damageMultiplier,double speedMultiplier){
  super(material,name,type,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174671
Project: 174671
Buggy source:
public ItemExcaliburRapier(ToolMaterial material,String name){
  super(material,name);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemExcaliburRapier(ToolMaterial material,String name,String type){
  super(material,name,type);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174672
Project: 174672
Buggy source:
public ItemGoldenPummel(ToolMaterial material,String name,double damageMultiplier,double speedMultiplier){
  super(material,name,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemGoldenPummel(ToolMaterial material,String name,String type,double damageMultiplier,double speedMultiplier){
  super(material,name,type,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174673
Project: 174673
Buggy source:
public ItemRequiem(ToolMaterial material,String name){
  super(material,name);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemRequiem(ToolMaterial material,String name,String type){
  super(material,name,type);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174674
Project: 174674
Buggy source:
public ItemShadowfall(ToolMaterial material,String name,double damageMultiplier,double speedMultiplier){
  super(material,name,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}

Fixed version (ground truth):
public ItemShadowfall(ToolMaterial material,String name,String type,double damageMultiplier,double speedMultiplier){
  super(material,name,type,damageMultiplier,speedMultiplier);
  this.setCreativeTab(ModTabs.tabLE);
}
Program: 174677
Project: 174677
Buggy source:
@SubscribeEvent public void onLivingDeath(LivingDeathEvent event){
  if (event.getSource().getTrueSource() instanceof EntityPlayer) {
    EntityPlayer player=(EntityPlayer)event.getSource().getTrueSource();
    EntityLivingBase enemy=event.getEntityLiving();
    IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
    if (playerInfo != null) {
      int experience=0;
      if (enemy instanceof EntityPlayer)       experience=50;
 else       experience=(int)(enemy.getMaxHealth() * 0.2);
      playerInfo.setPlayerExperience(playerInfo.getPlayerExperience() + experience + 1000);
      if (playerInfo.getPlayerExperience() > playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel())) {
        playerInfo.setPlayerLevel(playerInfo.getPlayerLevel() + 1);
        playerInfo.setSkillPoints(playerInfo.getSkillPoints() + 1);
      }
      LostEclipse.network.sendTo(new PacketUpdatePlayerInformation(playerInfo),(EntityPlayerMP)player);
    }
  }
}

Fixed version (ground truth):
@SubscribeEvent public void onLivingDeath(LivingDeathEvent event){
  if (event.getSource().getTrueSource() instanceof EntityPlayer) {
    EntityPlayer player=(EntityPlayer)event.getSource().getTrueSource();
    EntityLivingBase enemy=event.getEntityLiving();
    IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
    if (playerInfo != null) {
      int experience=0;
      if (enemy instanceof EntityPlayer)       experience=50;
 else       experience=(int)(enemy.getMaxHealth() * 0.2);
      playerInfo.setPlayerExperience(playerInfo.getPlayerExperience() + experience + 1000);
      while (playerInfo.getPlayerExperience() > playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel())) {
        playerInfo.setPlayerLevel(playerInfo.getPlayerLevel() + 1);
        playerInfo.setSkillPoints(playerInfo.getSkillPoints() + 1);
      }
      LostEclipse.network.sendTo(new PacketUpdatePlayerInformation(playerInfo),(EntityPlayerMP)player);
    }
  }
}
Program: 174679
Project: 174679
Buggy source:
@SubscribeEvent public void onLivingDeath(LivingDeathEvent event){
  if (event.getSource().getTrueSource() instanceof EntityPlayer) {
    EntityPlayer player=(EntityPlayer)event.getSource().getTrueSource();
    EntityLivingBase enemy=event.getEntityLiving();
    IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
    if (playerInfo != null) {
      int experience=0;
      if (enemy instanceof EntityPlayer)       experience=50;
 else       experience=(int)(enemy.getMaxHealth() * 0.2);
      playerInfo.setPlayerExperience(playerInfo.getPlayerExperience() + experience);
      if (playerInfo.getPlayerExperience() > playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel())) {
        playerInfo.setPlayerLevel(playerInfo.getPlayerLevel() + 1);
        playerInfo.setSkillPoints(playerInfo.getSkillPoints() + 1);
      }
      LostEclipse.network.sendTo(new PacketUpdatePlayerInformation(playerInfo),(EntityPlayerMP)player);
      LostEclipse.LOGGER.info("String_Node_Str" + event.getSource().damageType);
    }
  }
}

Fixed version (ground truth):
@SubscribeEvent public void onLivingDeath(LivingDeathEvent event){
  if (event.getSource().getTrueSource() instanceof EntityPlayer) {
    EntityPlayer player=(EntityPlayer)event.getSource().getTrueSource();
    EntityLivingBase enemy=event.getEntityLiving();
    IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
    if (playerInfo != null) {
      int experience=0;
      if (enemy instanceof EntityPlayer)       experience=50;
 else       experience=(int)(enemy.getMaxHealth() * 0.2);
      playerInfo.setPlayerExperience(playerInfo.getPlayerExperience() + experience);
      if (playerInfo.getPlayerExperience() > playerInfo.getLevelUpExperience(playerInfo.getPlayerLevel())) {
        playerInfo.setPlayerLevel(playerInfo.getPlayerLevel() + 1);
        playerInfo.setSkillPoints(playerInfo.getSkillPoints() + 1);
      }
      LostEclipse.network.sendTo(new PacketUpdatePlayerInformation(playerInfo),(EntityPlayerMP)player);
    }
  }
}
Program: 174681
Project: 174681
Buggy source:
@Override public ItemStack apply(ItemStack stack,Random rand,LootContext context){
  if (context instanceof CustomLootContext) {
    CustomLootContext customContext=(CustomLootContext)context;
    BlockPos pos=customContext.getChestPos();
    NBTTagCompound nbt;
    if (!stack.hasTagCompound())     nbt=new NBTTagCompound();
 else     nbt=stack.getTagCompound();
    ItemGenerator.create(stack,nbt,pos);
    stack.setTagCompound(nbt);
    stack.setStackDisplayName(Rarity.getRarity(nbt).getColor() + stack.getDisplayName());
    return stack;
  }
  return stack;
}

Fixed version (ground truth):
@Override public ItemStack apply(ItemStack stack,Random rand,LootContext context){
  if (context instanceof CustomLootContext) {
    CustomLootContext customContext=(CustomLootContext)context;
    BlockPos pos;
    NBTTagCompound nbt;
    if (customContext.getChestPos() != null)     pos=customContext.getChestPos();
 else     pos=context.getLootedEntity().getPosition();
    if (!stack.hasTagCompound())     nbt=new NBTTagCompound();
 else     nbt=stack.getTagCompound();
    ItemGenerator.create(stack,nbt,pos);
    stack.setTagCompound(nbt);
    stack.setStackDisplayName(Rarity.getRarity(nbt).getColor() + stack.getDisplayName());
    return stack;
  }
  return stack;
}
Program: 174682
Project: 174682
Buggy source:
@EventHandler public void preInit(FMLPreInitializationEvent event){
  ModCapabilities.registerCapabilities();
  MinecraftForge.EVENT_BUS.register(new EventPlayerLoggedIn());
  proxy.preInit(event);
  network=NetworkRegistry.INSTANCE.newSimpleChannel(Reference.MODID);
  network.registerMessage(PacketClassGui.Handler.class,PacketClassGui.class,0,Side.CLIENT);
  network.registerMessage(PacketClassSelection.Handler.class,PacketClassSelection.class,1,Side.SERVER);
}

Fixed version (ground truth):
@EventHandler public void preInit(FMLPreInitializationEvent event){
  ModCapabilities.registerCapabilities();
  ModEvents.registerEvents();
  proxy.preInit(event);
  network=NetworkRegistry.INSTANCE.newSimpleChannel(Reference.MODID);
  network.registerMessage(PacketClassGui.Handler.class,PacketClassGui.class,0,Side.CLIENT);
  network.registerMessage(PacketClassSelection.Handler.class,PacketClassSelection.class,1,Side.SERVER);
  network.registerMessage(PacketUpdatePlayerInformation.Handler.class,PacketUpdatePlayerInformation.class,2,Side.CLIENT);
}
Program: 174683
Project: 174683
Buggy source:
@Override protected void actionPerformed(GuiButton button) throws IOException {
  EntityPlayer player=mc.player;
  if (player != null) {
    if (button == warrior)     MineHackSlash.network.sendToServer(new PacketClassSelection(1));
 else     if (button == mage)     MineHackSlash.network.sendToServer(new PacketClassSelection(2));
 else     if (button == hunter)     MineHackSlash.network.sendToServer(new PacketClassSelection(3));
    this.mc.player.closeScreen();
  }
}

Fixed version (ground truth):
@Override protected void actionPerformed(GuiButton button) throws IOException {
  EntityPlayer player=mc.player;
  IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
  if (player != null && playerInfo != null) {
    if (button == warrior) {
      playerInfo.setPlayerClass(1);
      MineHackSlash.network.sendToServer(new PacketClassSelection(1));
    }
 else     if (button == mage) {
      playerInfo.setPlayerClass(2);
      MineHackSlash.network.sendToServer(new PacketClassSelection(2));
    }
 else     if (button == hunter) {
      playerInfo.setPlayerClass(3);
      MineHackSlash.network.sendToServer(new PacketClassSelection(3));
    }
    playerInfo.setPlayerLevel(1);
    this.mc.player.closeScreen();
  }
}
Program: 174684
Project: 174684
Buggy source:
@SubscribeEvent public void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event){
  IPlayerInformation playerInfo=event.player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
  if (playerInfo != null && playerInfo.getPlayerClass() == 0)   MineHackSlash.network.sendTo(new PacketClassGui(),(EntityPlayerMP)event.player);
}

Fixed version (ground truth):
@SubscribeEvent public void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event){
  IPlayerInformation playerInfo=event.player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
  if (playerInfo != null && playerInfo.getPlayerClass() == 0)   MineHackSlash.network.sendTo(new PacketClassGui(),(EntityPlayerMP)event.player);
 else   if (playerInfo != null && playerInfo.getPlayerClass() > 0)   MineHackSlash.network.sendTo(new PacketUpdatePlayerInformation(playerInfo),(EntityPlayerMP)event.player);
}
Program: 174685
Project: 174685
Buggy source:
@Override public IMessage onMessage(final PacketClassSelection message,final MessageContext ctx){
  IThreadListener mainThread=(WorldServer)ctx.getServerHandler().player.getEntityWorld();
  mainThread.addScheduledTask(new Runnable(){
    @Override public void run(){
      EntityPlayer player=ctx.getServerHandler().player;
      IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
      if (playerInfo != null && !player.getEntityWorld().isRemote) {
        if (message.playerClass == 1)         playerInfo.setPlayerClass(1);
 else         if (message.playerClass == 2) {
          playerInfo.setPlayerClass(2);
          System.out.println("String_Node_Str");
        }
 else         if (message.playerClass == 3)         playerInfo.setPlayerClass(3);
      }
    }
  }
);
  return null;
}

Fixed version (ground truth):
@Override public IMessage onMessage(final PacketClassSelection message,final MessageContext ctx){
  IThreadListener mainThread=(WorldServer)ctx.getServerHandler().player.getEntityWorld();
  mainThread.addScheduledTask(new Runnable(){
    @Override public void run(){
      EntityPlayer player=ctx.getServerHandler().player;
      IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
      if (playerInfo != null && !player.getEntityWorld().isRemote) {
        if (message.playerClass == 1)         playerInfo.setPlayerClass(1);
 else         if (message.playerClass == 2)         playerInfo.setPlayerClass(2);
 else         if (message.playerClass == 3)         playerInfo.setPlayerClass(3);
        playerInfo.setPlayerLevel(1);
      }
    }
  }
);
  return null;
}
Program: 174686
Project: 174686
Buggy source:
@Override public void run(){
  EntityPlayer player=ctx.getServerHandler().player;
  IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
  if (playerInfo != null && !player.getEntityWorld().isRemote) {
    if (message.playerClass == 1)     playerInfo.setPlayerClass(1);
 else     if (message.playerClass == 2) {
      playerInfo.setPlayerClass(2);
      System.out.println("String_Node_Str");
    }
 else     if (message.playerClass == 3)     playerInfo.setPlayerClass(3);
  }
}

Fixed version (ground truth):
@Override public void run(){
  EntityPlayer player=ctx.getServerHandler().player;
  IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
  if (playerInfo != null && !player.getEntityWorld().isRemote) {
    if (message.playerClass == 1)     playerInfo.setPlayerClass(1);
 else     if (message.playerClass == 2)     playerInfo.setPlayerClass(2);
 else     if (message.playerClass == 3)     playerInfo.setPlayerClass(3);
    playerInfo.setPlayerLevel(1);
  }
}
Program: 174687
Project: 174687
Buggy source:
@Override public void init(FMLInitializationEvent event){
}

Fixed version (ground truth):
@Override public void init(FMLInitializationEvent event){
  bindingP=new KeyBinding("String_Node_Str",Keyboard.KEY_P,"String_Node_Str");
  ClientRegistry.registerKeyBinding(bindingP);
}
Program: 174688
Project: 174688
Buggy source:
@EventHandler public void preInit(FMLPreInitializationEvent event){
  ModLootTables.register();
  ModCapabilities.registerCapabilities();
  ModEvents.registerEvents();
  LootFunctionManager.registerFunction(new CreateStats.Serializer());
  proxy.preInit(event);
  network=NetworkRegistry.INSTANCE.newSimpleChannel(Reference.MODID);
  network.registerMessage(PacketClassGui.Handler.class,PacketClassGui.class,0,Side.CLIENT);
  network.registerMessage(PacketClassSelection.Handler.class,PacketClassSelection.class,1,Side.SERVER);
  network.registerMessage(PacketUpdatePlayerInformation.Handler.class,PacketUpdatePlayerInformation.class,2,Side.CLIENT);
}

Fixed version (ground truth):
@EventHandler public void preInit(FMLPreInitializationEvent event){
  ModLootTables.register();
  ModCapabilities.registerCapabilities();
  ModEvents.registerEvents();
  LootFunctionManager.registerFunction(new CreateStats.Serializer());
  proxy.preInit(event);
  network=NetworkRegistry.INSTANCE.newSimpleChannel(Reference.MODID);
  network.registerMessage(PacketClassGui.Handler.class,PacketClassGui.class,0,Side.CLIENT);
  network.registerMessage(PacketClassSelection.Handler.class,PacketClassSelection.class,1,Side.SERVER);
  network.registerMessage(PacketUpdatePlayerInformation.Handler.class,PacketUpdatePlayerInformation.class,2,Side.CLIENT);
  network.registerMessage(PacketUpdatePlayerStats.Handler.class,PacketUpdatePlayerStats.class,3,Side.CLIENT);
  network.registerMessage(PacketUpdateIncreaseStat.Handler.class,PacketUpdateIncreaseStat.class,4,Side.SERVER);
}
Program: 174689
Project: 174689
Buggy source:
@Override public NBTBase writeNBT(Capability<IPlayerInformation> capability,IPlayerInformation instance,EnumFacing side){
  NBTTagCompound nbt=new NBTTagCompound();
  nbt.setInteger("String_Node_Str",instance.getPlayerClass());
  nbt.setInteger("String_Node_Str",instance.getPlayerLevel());
  nbt.setInteger("String_Node_Str",instance.getPlayerExperience());
  nbt.setInteger("String_Node_Str",instance.getSkillPoints());
  nbt.setInteger("String_Node_Str",instance.getStrengthStat());
  nbt.setInteger("String_Node_Str",instance.getAgilityStat());
  nbt.setInteger("String_Node_Str",instance.getDexterityStat());
  nbt.setInteger("String_Node_Str",instance.getIntelligenceStat());
  nbt.setInteger("String_Node_Str",instance.getWisdomStat());
  nbt.setInteger("String_Node_Str",instance.getFortitudeStat());
  return nbt;
}

Fixed version (ground truth):
@Override public NBTBase writeNBT(Capability<IPlayerInformation> capability,IPlayerInformation instance,EnumFacing side){
  NBTTagCompound nbt=new NBTTagCompound();
  nbt.setInteger("String_Node_Str",instance.getPlayerClass());
  nbt.setInteger("String_Node_Str",instance.getPlayerLevel());
  nbt.setInteger("String_Node_Str",instance.getPlayerExperience());
  nbt.setInteger("String_Node_Str",instance.getSkillPoints());
  nbt.setInteger("String_Node_Str",instance.getStrengthStat());
  nbt.setInteger("String_Node_Str",instance.getAgilityStat());
  nbt.setInteger("String_Node_Str",instance.getDexterityStat());
  nbt.setInteger("String_Node_Str",instance.getIntelligenceStat());
  nbt.setInteger("String_Node_Str",instance.getWisdomStat());
  nbt.setInteger("String_Node_Str",instance.getFortitudeStat());
  nbt.setInteger("String_Node_Str",instance.getBonusStrengthStat());
  nbt.setInteger("String_Node_Str",instance.getBonusAgilityStat());
  nbt.setInteger("String_Node_Str",instance.getBonusDexterityStat());
  nbt.setInteger("String_Node_Str",instance.getBonusIntelligenceStat());
  nbt.setInteger("String_Node_Str",instance.getBonusWisdomStat());
  nbt.setInteger("String_Node_Str",instance.getBonusFortitudeStat());
  return nbt;
}
Program: 174690
Project: 174690
Buggy source:
@SubscribeEvent public void playerClone(PlayerEvent.Clone event){
  IPlayerInformation oldInfo=getPlayerInformation(event.getOriginal());
  IPlayerInformation newInfo=getPlayerInformation(event.getEntityLiving());
  if (newInfo != null && oldInfo != null) {
    newInfo.setPlayerClass(oldInfo.getPlayerClass());
    newInfo.setPlayerLevel(oldInfo.getPlayerLevel());
    newInfo.setPlayerExperience(oldInfo.getPlayerExperience());
    newInfo.setSkillPoints(oldInfo.getSkillPoints());
    newInfo.setStrengthStat(oldInfo.getStrengthStat());
    newInfo.setAgilityStat(oldInfo.getAgilityStat());
    newInfo.setDexterityStat(oldInfo.getDexterityStat());
    newInfo.setIntelligenceStat(oldInfo.getIntelligenceStat());
    newInfo.setWisdomStat(oldInfo.getWisdomStat());
    newInfo.setFortitudeStat(oldInfo.getFortitudeStat());
  }
}

Fixed version (ground truth):
@SubscribeEvent public void playerClone(PlayerEvent.Clone event){
  IPlayerInformation oldInfo=getPlayerInformation(event.getOriginal());
  IPlayerInformation newInfo=getPlayerInformation(event.getEntityLiving());
  if (newInfo != null && oldInfo != null) {
    newInfo.setPlayerClass(oldInfo.getPlayerClass());
    newInfo.setPlayerLevel(oldInfo.getPlayerLevel());
    newInfo.setPlayerExperience(oldInfo.getPlayerExperience());
    newInfo.setSkillPoints(oldInfo.getSkillPoints());
    newInfo.setStrengthStat(oldInfo.getStrengthStat());
    newInfo.setAgilityStat(oldInfo.getAgilityStat());
    newInfo.setDexterityStat(oldInfo.getDexterityStat());
    newInfo.setIntelligenceStat(oldInfo.getIntelligenceStat());
    newInfo.setWisdomStat(oldInfo.getWisdomStat());
    newInfo.setFortitudeStat(oldInfo.getFortitudeStat());
    newInfo.setBonusStrengthStat(oldInfo.getBonusStrengthStat());
    newInfo.setBonusAgilityStat(oldInfo.getBonusAgilityStat());
    newInfo.setBonusDexterityStat(oldInfo.getBonusDexterityStat());
    newInfo.setBonusIntelligenceStat(oldInfo.getBonusIntelligenceStat());
    newInfo.setBonusWisdomStat(oldInfo.getBonusWisdomStat());
    newInfo.setBonusFortitudeStat(oldInfo.getBonusFortitudeStat());
  }
}
Program: 174692
Project: 174692
Buggy source:
@Override public void readNBT(Capability<IPlayerInformation> capability,IPlayerInformation instance,EnumFacing side,NBTBase nbt){
  NBTTagCompound compound=(NBTTagCompound)nbt;
  instance.setPlayerClass(compound.getInteger("String_Node_Str"));
  instance.setPlayerLevel(compound.getInteger("String_Node_Str"));
  instance.setPlayerExperience(compound.getInteger("String_Node_Str"));
  instance.setSkillPoints(compound.getInteger("String_Node_Str"));
  instance.setStrengthStat(compound.getInteger("String_Node_Str"));
  instance.setAgilityStat(compound.getInteger("String_Node_Str"));
  instance.setDexterityStat(compound.getInteger("String_Node_Str"));
  instance.setIntelligenceStat(compound.getInteger("String_Node_Str"));
  instance.setWisdomStat(compound.getInteger("String_Node_Str"));
  instance.setFortitudeStat(compound.getInteger("String_Node_Str"));
}

Fixed version (ground truth):
@Override public void readNBT(Capability<IPlayerInformation> capability,IPlayerInformation instance,EnumFacing side,NBTBase nbt){
  NBTTagCompound compound=(NBTTagCompound)nbt;
  instance.setPlayerClass(compound.getInteger("String_Node_Str"));
  instance.setPlayerLevel(compound.getInteger("String_Node_Str"));
  instance.setPlayerExperience(compound.getInteger("String_Node_Str"));
  instance.setSkillPoints(compound.getInteger("String_Node_Str"));
  instance.setStrengthStat(compound.getInteger("String_Node_Str"));
  instance.setAgilityStat(compound.getInteger("String_Node_Str"));
  instance.setDexterityStat(compound.getInteger("String_Node_Str"));
  instance.setIntelligenceStat(compound.getInteger("String_Node_Str"));
  instance.setWisdomStat(compound.getInteger("String_Node_Str"));
  instance.setFortitudeStat(compound.getInteger("String_Node_Str"));
  instance.setBonusStrengthStat(compound.getInteger("String_Node_Str"));
  instance.setBonusAgilityStat(compound.getInteger("String_Node_Str"));
  instance.setBonusDexterityStat(compound.getInteger("String_Node_Str"));
  instance.setBonusIntelligenceStat(compound.getInteger("String_Node_Str"));
  instance.setBonusWisdomStat(compound.getInteger("String_Node_Str"));
  instance.setBonusFortitudeStat(compound.getInteger("String_Node_Str"));
}
Program: 174693
Project: 174693
Buggy source:
@Override protected void actionPerformed(GuiButton button) throws IOException {
}

Fixed version (ground truth):
@Override protected void actionPerformed(GuiButton button) throws IOException {
  EntityPlayer player=mc.player;
  IPlayerInformation playerInfo=player.getCapability(CapabilityPlayerInformation.PLAYER_INFORMATION,null);
  if (player != null && playerInfo != null && playerInfo.getSkillPoints() > 0) {
    if (button == plusStrength)     LostEclipse.network.sendToServer(new PacketUpdateIncreaseStat(1));
 else     if (button == plusAgility)     LostEclipse.network.sendToServer(new PacketUpdateIncreaseStat(2));
 else     if (button == plusDexterity)     LostEclipse.network.sendToServer(new PacketUpdateIncreaseStat(3));
 else     if (button == plusIntelligence)     LostEclipse.network.sendToServer(new PacketUpdateIncreaseStat(4));
 else     if (button == plusWisdom)     LostEclipse.network.sendToServer(new PacketUpdateIncreaseStat(5));
 else     if (button == plusFortitude)     LostEclipse.network.sendToServer(new PacketUpdateIncreaseStat(6));
    playerInfo.setSkillPoints(playerInfo.getSkillPoints() - 1);
  }
}
Program: 174694
Project: 174694
Buggy source:
@Override public void initGui(){
}

Fixed version (ground truth):
@Override public void initGui(){
  plusStrength=new GuiButton(0,this.width / 2 + 95,139,10,10,"String_Node_Str");
  plusAgility=new GuiButton(1,this.width / 2 + 95,149,10,10,"String_Node_Str");
  plusDexterity=new GuiButton(2,this.width / 2 + 95,159,10,10,"String_Node_Str");
  plusIntelligence=new GuiButton(3,this.width / 2 + 95,169,10,10,"String_Node_Str");
  plusWisdom=new GuiButton(4,this.width / 2 + 95,179,10,10,"String_Node_Str");
  plusFortitude=new GuiButton(5,this.width / 2 + 95,189,10,10,"String_Node_Str");
  this.buttonList.add(plusStrength);
  this.buttonList.add(plusAgility);
  this.buttonList.add(plusDexterity);
  this.buttonList.add(plusIntelligence);
  this.buttonList.add(plusWisdom);
  this.buttonList.add(plusFortitude);
}
Program: 174696
Project: 174696
Buggy source:
public static void registerEvents(){
  MinecraftForge.EVENT_BUS.register(new EventPlayerLoggedIn());
  MinecraftForge.EVENT_BUS.register(new EventLivingDeath());
  MinecraftForge.EVENT_BUS.register(new EventInput());
  MinecraftForge.EVENT_BUS.register(new EventLivingHurtAttack());
  MinecraftForge.EVENT_BUS.register(new EventItemTooltip());
  MinecraftForge.EVENT_BUS.register(new ModWeapons());
  MinecraftForge.EVENT_BUS.register(new EventLoadLootTable());
}

Fixed version (ground truth):
public static void registerEvents(){
  MinecraftForge.EVENT_BUS.register(new EventPlayerLoggedIn());
  MinecraftForge.EVENT_BUS.register(new EventLivingDeath());
  MinecraftForge.EVENT_BUS.register(new EventInput());
  MinecraftForge.EVENT_BUS.register(new EventLivingHurtAttack());
  MinecraftForge.EVENT_BUS.register(new EventItemTooltip());
  MinecraftForge.EVENT_BUS.register(new ModWeapons());
  MinecraftForge.EVENT_BUS.register(new EventLoadLootTable());
  MinecraftForge.EVENT_BUS.register(new EventPlayerTick());
}
Program: 174699
Project: 174699
Buggy source:
private static void determineRemovedItems(Random random){
  Set<String> removedItems=new HashSet<>(Settings.getRemovedItems());
  if (Settings.getMaxRandomRemovedItems() < 1) {
    Settings.setCurrentRemovedItems(new HashSet<>(0));
  }
  int totalItemsRemoved=Settings.getMinRandomRemovedItems();
  totalItemsRemoved+=random.nextInt(Settings.getMaxRandomRemovedItems() - totalItemsRemoved + 1);
  List<String> removableItems=DataFromFile.getRandomRemovableItems();
  int chosenRemovedItems=0;
  while (chosenRemovedItems < totalItemsRemoved) {
    int removedItemIndex=random.nextInt(removableItems.size());
    String removedItem=removableItems.get(removedItemIndex);
    if (!removedItems.contains(removedItem) && removableItems.contains(removedItem)) {
      removedItems.add(removedItem);
      ++chosenRemovedItems;
    }
  }
  Settings.setCurrentRemovedItems(removedItems);
}

Fixed version (ground truth):
private static void determineRemovedItems(Random random){
  Set<String> removedItems=new HashSet<>(Settings.getRemovedItems());
  if (Settings.getMaxRandomRemovedItems() < 1) {
    Settings.setCurrentRemovedItems(new HashSet<>(0));
  }
  int totalItemsRemoved=Settings.getMinRandomRemovedItems();
  totalItemsRemoved+=random.nextInt(Settings.getMaxRandomRemovedItems() - totalItemsRemoved + 1);
  List<String> removableItems=new ArrayList<>(DataFromFile.getRandomRemovableItems());
  int chosenRemovedItems=0;
  while (chosenRemovedItems < totalItemsRemoved && !removableItems.isEmpty()) {
    int removedItemIndex=random.nextInt(removableItems.size());
    String removedItem=removableItems.get(removedItemIndex);
    if (!removedItems.contains(removedItem)) {
      removedItems.add(removedItem);
      removableItems.remove(removedItem);
      ++chosenRemovedItems;
    }
  }
  Settings.setCurrentRemovedItems(removedItems);
}
Program: 174700
Project: 174700
Buggy source:
private void handleNodeAccess(String nodeName,NodeType nodeType){
switch (nodeType) {
case ITEM_LOCATION:
    String item=itemRandomizer.getItem(nodeName);
  if (!Settings.getCurrentRemovedItems().contains(item)) {
    queuedUpdates.add(item);
  }
break;
case MAP_LOCATION:
case EVENT:
case EXIT:
case GLITCH:
queuedUpdates.add(nodeName);
break;
case SHOP:
for (String shopItem : shopRandomizer.getShopItems(nodeName)) {
if (!accessedNodes.contains(shopItem) && !queuedUpdates.contains(shopItem)) {
queuedUpdates.add(shopItem);
}
}
break;
}
}

Fixed version (ground truth):
private void handleNodeAccess(String nodeName,NodeType nodeType){
switch (nodeType) {
case ITEM_LOCATION:
    String item=itemRandomizer.getItem(nodeName);
  if (!Settings.getCurrentRemovedItems().contains(item)) {
    queuedUpdates.add(item);
  }
break;
case MAP_LOCATION:
case EVENT:
case EXIT:
case GLITCH:
queuedUpdates.add(nodeName);
break;
case SHOP:
for (String shopItem : shopRandomizer.getShopItems(nodeName)) {
if (!accessedNodes.contains(shopItem) && !queuedUpdates.contains(shopItem) && !Settings.getCurrentRemovedItems().contains(shopItem)) {
queuedUpdates.add(shopItem);
}
}
break;
}
}
Program: 174702
Project: 174702
Buggy source:
public static void clearAll(){
  mapOfChestIdentifyingInfoToGameObject.clear();
  mapOfChestIdentifyingInfoToBlock.clear();
  mapOfShopBlockToShopObjects.clear();
  mantraTablets.clear();
  nextReplacedItemFlag=2708;
}

Fixed version (ground truth):
public static void clearAll(){
  mapOfChestIdentifyingInfoToGameObject.clear();
  mapOfChestIdentifyingInfoToBlock.clear();
  mapOfShopBlockToShopObjects.clear();
  mantraTablets.clear();
  mapOfWorldFlagToAssignedReplacementFlag.clear();
  nextReplacedItemFlag=2708;
}
Program: 174708
Project: 174708
Buggy source:
public static void updateBlock(String itemLocation,String randomizedContents){
  Map<String,GameObjectId> nameToDataMap=DataFromFile.getMapOfItemToUsefulIdentifyingRcdData();
  GameObjectId itemNewContentsData=nameToDataMap.get(randomizedContents);
  GameObjectId itemLocationData=nameToDataMap.get(itemLocation);
  List<Block> blocksToModify=mapOfChestIdentifyingInfoToBlock.get(nameToDataMap.get(itemLocation));
  for (  Block block : blocksToModify) {
    for (    BlockContents blockContents : block.getBlockContents()) {
      if (blockContents instanceof BlockFlagData) {
        BlockFlagData flagData=(BlockFlagData)blockContents;
        if (flagData.getWorldFlag() == itemLocationData.getWorldFlag()) {
          flagData.setWorldFlag((short)itemNewContentsData.getWorldFlag());
          flagData.setFlagValue((short)2);
        }
 else         if (flagData.getWorldFlag() == 552) {
          flagData.setWorldFlag((short)itemNewContentsData.getWorldFlag());
          flagData.setFlagValue((short)2);
        }
      }
 else       if (blockContents instanceof BlockItemData) {
        BlockItemData itemData=(BlockItemData)blockContents;
        if (itemData.getItemData() == itemLocationData.getInventoryArg()) {
          itemData.setItemData(itemNewContentsData.getInventoryArg());
        }
      }
    }
  }
}

Fixed version (ground truth):
public static void updateBlock(String itemLocation,String randomizedContents){
  Map<String,GameObjectId> nameToDataMap=DataFromFile.getMapOfItemToUsefulIdentifyingRcdData();
  GameObjectId itemNewContentsData=nameToDataMap.get(randomizedContents);
  GameObjectId itemLocationData=nameToDataMap.get(itemLocation);
  List<Block> blocksToModify=mapOfChestIdentifyingInfoToBlock.get(nameToDataMap.get(itemLocation));
  for (  Block block : blocksToModify) {
    for (    BlockContents blockContents : block.getBlockContents()) {
      if (blockContents instanceof BlockFlagData) {
        BlockFlagData flagData=(BlockFlagData)blockContents;
        if (flagData.getWorldFlag() == itemLocationData.getWorldFlag()) {
          if (flagData.getWorldFlag() == 209) {
            flagData.setFlagValue((short)1);
          }
 else {
            flagData.setFlagValue((short)2);
          }
          flagData.setWorldFlag((short)itemNewContentsData.getWorldFlag());
        }
 else         if (flagData.getWorldFlag() == 552) {
          flagData.setWorldFlag((short)itemNewContentsData.getWorldFlag());
          flagData.setFlagValue((short)2);
        }
      }
 else       if (blockContents instanceof BlockItemData) {
        BlockItemData itemData=(BlockItemData)blockContents;
        if (itemData.getItemData() == itemLocationData.getInventoryArg()) {
          itemData.setItemData(itemNewContentsData.getInventoryArg());
        }
      }
    }
  }
}
Program: 174709
Project: 174709
Buggy source:
private GameDataTracker(){
  nextReplacedItemFlag=2708;
}

Fixed version (ground truth):
private GameDataTracker(){
}
Program: 174711
Project: 174711
Buggy source:
public boolean validRequirements(String item,String location){
  if (location.contains("String_Node_Str")) {
    location=location.substring(0,location.indexOf("String_Node_Str") + 1);
  }
  NodeWithRequirements node=mapOfNodeNameToRequirementsObject.get(location);
  if (node == null) {
    FileUtils.log("String_Node_Str" + item);
  }
  if (item.contains("String_Node_Str")) {
    item="String_Node_Str";
  }
 else   if (item.contains("String_Node_Str")) {
    item="String_Node_Str";
  }
  return mapOfNodeNameToRequirementsObject.get(location).canContainItem(item);
}

Fixed version (ground truth):
public boolean validRequirements(String item,String location){
  if (location.contains("String_Node_Str")) {
    location=location.substring(0,location.indexOf("String_Node_Str") + 1);
  }
  NodeWithRequirements node=mapOfNodeNameToRequirementsObject.get(location);
  if (node == null) {
    FileUtils.log("String_Node_Str" + item);
  }
  if (item.contains("String_Node_Str")) {
    item="String_Node_Str";
  }
 else   if (item.contains("String_Node_Str")) {
    item="String_Node_Str";
  }
 else   if (item.contains("String_Node_Str")) {
    if (DataFromFile.LOCATIONS_RELATED_TO_BLOCKS.contains(location) && !"String_Node_Str".equals(location)) {
      return false;
    }
    if ("String_Node_Str".equals(location) || "String_Node_Str".equals(location) || "String_Node_Str".equals(location)) {
      return false;
    }
  }
  return mapOfNodeNameToRequirementsObject.get(location).canContainItem(item);
}
Program: 174712
Project: 174712
Buggy source:
public void updateFiles() throws Exception {
  List<String> locationsRelatedToBlocks=Arrays.asList("String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str","String_Node_Str");
  for (  Map.Entry<String,String> locationAndItem : mapOfItemLocationToItem.entrySet()) {
    if (!locationAndItem.getKey().equals(locationAndItem.getValue())) {
      if (locationsRelatedToBlocks.contains(locationAndItem.getKey())) {
        GameDataTracker.updateBlock(locationAndItem.getKey(),locationAndItem.getValue());
      }
      GameDataTracker.writeLocationContents(locationAndItem.getKey(),locationAndItem.getValue());
    }
  }
}

Fixed version (ground truth):
public void updateFiles() throws Exception {
  for (  Map.Entry<String,String> locationAndItem : mapOfItemLocationToItem.entrySet()) {
    if (!locationAndItem.getKey().equals(locationAndItem.getValue())) {
      if (DataFromFile.LOCATIONS_RELATED_TO_BLOCKS.contains(locationAndItem.getKey())) {
        GameDataTracker.updateBlock(locationAndItem.getKey(),locationAndItem.getValue());
      }
      GameDataTracker.writeLocationContents(locationAndItem.getKey(),locationAndItem.getValue());
    }
  }
}
Program: 174716
Project: 174716
Buggy source:
public CheckboxPanel(){
  super(new MigLayout("String_Node_Str","String_Node_Str","String_Node_Str"));
  fullItemAccess=new JCheckBox("String_Node_Str");
  fullItemAccess.setSelected(Settings.isFullItemAccess());
  add(fullItemAccess);
  enableDamageBoostRequirements=new JCheckBox("String_Node_Str");
  enableDamageBoostRequirements.setSelected(Settings.isRequireSoftwareComboForKeyFairy());
  add(enableDamageBoostRequirements);
  requireSoftwareComboForKeyFairy=new JCheckBox("String_Node_Str");
  requireSoftwareComboForKeyFairy.setSelected(Settings.isRequireSoftwareComboForKeyFairy());
  add(requireSoftwareComboForKeyFairy);
  randomizeForbiddenTreasure=new JCheckBox("String_Node_Str");
  randomizeForbiddenTreasure.setSelected(Settings.isRandomizeForbiddenTreasure());
  add(randomizeForbiddenTreasure);
  randomizeCoinChests=new JCheckBox("String_Node_Str");
  randomizeCoinChests.setSelected(Settings.isRandomizeCoinChests());
  add(randomizeCoinChests);
}

Fixed version (ground truth):
public CheckboxPanel(){
  super(new MigLayout("String_Node_Str","String_Node_Str","String_Node_Str"));
  fullItemAccess=new JCheckBox("String_Node_Str");
  fullItemAccess.setSelected(Settings.isFullItemAccess());
  add(fullItemAccess);
  enableDamageBoostRequirements=new JCheckBox("String_Node_Str");
  enableDamageBoostRequirements.setSelected(Settings.isEnableDamageBoostRequirements());
  add(enableDamageBoostRequirements);
  requireSoftwareComboForKeyFairy=new JCheckBox("String_Node_Str");
  requireSoftwareComboForKeyFairy.setSelected(Settings.isRequireSoftwareComboForKeyFairy());
  add(requireSoftwareComboForKeyFairy);
  randomizeForbiddenTreasure=new JCheckBox("String_Node_Str");
  randomizeForbiddenTreasure.setSelected(Settings.isRandomizeForbiddenTreasure());
  add(randomizeForbiddenTreasure);
  randomizeCoinChests=new JCheckBox("String_Node_Str");
  randomizeCoinChests.setSelected(Settings.isRandomizeCoinChests());
  add(randomizeCoinChests);
}
Program: 174718
Project: 174718
Buggy source:
public static void main(String[] args){
  if (true) {
    Settings.startingSeed=401636804;
    Settings.randomizeShops=true;
    Settings.nonRandomizedItems.add("String_Node_Str");
    Settings.laMulanaBaseDir="String_Node_Str";
    Settings.rcdFileLocation="String_Node_Str";
    Settings.datFileLocation="String_Node_Str";
    File directory=new File(Long.toString(Settings.startingSeed));
    directory.mkdir();
    try {
      doTheThing();
    }
 catch (    Exception ex) {
      FileUtils.log("String_Node_Str" + ex.getMessage());
      ex.printStackTrace();
    }
    FileUtils.closeAll();
  }
 else {
    SwingUtilities.invokeLater(new RandomizerRunnable());
  }
}

Fixed version (ground truth):
public static void main(String[] args){
  if (true) {
    Settings.randomizeShops=true;
    Settings.nonRandomizedItems.add("String_Node_Str");
    Settings.laMulanaBaseDir="String_Node_Str";
    Settings.rcdFileLocation="String_Node_Str";
    Settings.datFileLocation="String_Node_Str";
    File directory=new File(Long.toString(Settings.startingSeed));
    directory.mkdir();
    try {
      doTheThing();
    }
 catch (    Exception ex) {
      FileUtils.log("String_Node_Str" + ex.getMessage());
      ex.printStackTrace();
    }
    FileUtils.closeAll();
  }
 else {
    SwingUtilities.invokeLater(new RandomizerRunnable());
  }
}
Program: 174719
Project: 174719
Buggy source:
public boolean updateForBosses(int attempt){
  List<Thread> threads=new ArrayList<>(accessibleBossNodes.size());
  List<AnkhJewelLockChecker> ankhJewelLockCheckers=new ArrayList<>();
  for (  String bossNode : accessibleBossNodes) {
    AnkhJewelLockChecker ankhJewelLockChecker=new AnkhJewelLockChecker(new AccessChecker(this),bossNode);
    ankhJewelLockCheckers.add(ankhJewelLockChecker);
    Thread thread=new Thread(ankhJewelLockChecker);
    threads.add(thread);
    thread.start();
  }
  try {
    for (    Thread thread : threads) {
      thread.join();
    }
  }
 catch (  InterruptedException ex) {
    FileUtils.log("String_Node_Str");
  }
  for (  AnkhJewelLockChecker ankhJewelLockChecker : ankhJewelLockCheckers) {
    if (!ankhJewelLockChecker.isEnoughAnkhJewelsToDefeatAllAccessibleBosses()) {
      return false;
    }
  }
  for (  String accessibleBoss : accessibleBossNodes) {
    markBossDefeated(accessibleBoss);
  }
  return true;
}

Fixed version (ground truth):
public boolean updateForBosses(int attempt){
  List<Thread> threads=new ArrayList<>(accessibleBossNodes.size());
  List<AnkhJewelLockChecker> ankhJewelLockCheckers=new ArrayList<>();
  for (  String bossNode : accessibleBossNodes) {
    AnkhJewelLockChecker ankhJewelLockChecker=new AnkhJewelLockChecker(new AccessChecker(this),bossNode);
    ankhJewelLockCheckers.add(ankhJewelLockChecker);
    Thread thread=new Thread(ankhJewelLockChecker);
    threads.add(thread);
    thread.start();
  }
  try {
    for (    Thread thread : threads) {
      thread.join();
    }
  }
 catch (  InterruptedException ex) {
    FileUtils.log("String_Node_Str");
  }
  for (  AnkhJewelLockChecker ankhJewelLockChecker : ankhJewelLockCheckers) {
    if (!ankhJewelLockChecker.isEnoughAnkhJewelsToDefeatAllAccessibleBosses()) {
      return false;
    }
  }
  NodeWithRequirements bossNode;
  List<String> copyAccessibleBossNodes=new ArrayList<>(accessibleBossNodes);
  for (  String accessibleBoss : copyAccessibleBossNodes) {
    bossNode=mapOfNodeNameToRequirementsObject.get(accessibleBoss.replace("String_Node_Str","String_Node_Str"));
    if (bossNode != null && !accessedNodes.contains(accessibleBoss)) {
      markBossAccessed(accessibleBoss);
    }
  }
  return true;
}
Program: 174720
Project: 174720
Buggy source:
public void markBossDefeated(String bossEventNodeName){
  accessedNodes.add(bossEventNodeName);
  NodeWithRequirements node;
  Set<String> nodesToRemove=new HashSet<>();
  for (  String nodeName : mapOfNodeNameToRequirementsObject.keySet()) {
    node=mapOfNodeNameToRequirementsObject.get(nodeName);
    if (node.updateRequirements(bossEventNodeName)) {
      handleNodeAccess(nodeName,node.getType());
      nodesToRemove.add(nodeName);
    }
  }
  for (  String nodeToRemove : nodesToRemove) {
    mapOfNodeNameToRequirementsObject.remove(nodeToRemove);
  }
}

Fixed version (ground truth):
public void markBossDefeated(String bossEventNodeName){
  if (!accessibleBossNodes.contains(bossEventNodeName)) {
    return;
  }
  markBossAccessed(bossEventNodeName);
  String bossDefeatedNodeName=bossEventNodeName.replace("String_Node_Str","String_Node_Str");
  mapOfNodeNameToRequirementsObject.remove(bossDefeatedNodeName);
  accessedNodes.add(bossDefeatedNodeName);
  NodeWithRequirements node;
  Set<String> nodesToRemove=new HashSet<>();
  for (  String nodeName : mapOfNodeNameToRequirementsObject.keySet()) {
    node=mapOfNodeNameToRequirementsObject.get(nodeName);
    if (node.updateRequirements(bossDefeatedNodeName)) {
      handleNodeAccess(nodeName,node.getType());
      nodesToRemove.add(nodeName);
    }
  }
  for (  String nodeToRemove : nodesToRemove) {
    mapOfNodeNameToRequirementsObject.remove(nodeToRemove);
  }
}
Program: 174721
Project: 174721
Buggy source:
public AccessChecker(AccessChecker accessChecker){
  this.mapOfNodeNameToRequirementsObject=copyRequirementsMap(accessChecker.mapOfNodeNameToRequirementsObject);
  this.itemRandomizer=accessChecker.itemRandomizer;
  this.shopRandomizer=accessChecker.shopRandomizer;
  this.accessedNodes=new ArrayList<>(accessChecker.accessedNodes);
  this.numberOfAccessibleAnkhJewels=accessChecker.numberOfAccessibleAnkhJewels;
}

Fixed version (ground truth):
public AccessChecker(AccessChecker accessChecker){
  this.mapOfNodeNameToRequirementsObject=copyRequirementsMap(accessChecker.mapOfNodeNameToRequirementsObject);
  this.itemRandomizer=accessChecker.itemRandomizer;
  this.shopRandomizer=accessChecker.shopRandomizer;
  this.accessedNodes=new HashSet<>(accessChecker.accessedNodes);
  this.accessibleBossNodes=new HashSet<>(accessChecker.accessibleBossNodes);
  this.numberOfAccessibleAnkhJewels=accessChecker.numberOfAccessibleAnkhJewels;
}