nus-yam/ex-repair huggingface dataset:
Program: 42092
Project: 42092
Buggy source:
@EventHandler public void onEntityDamagebyEntity(EntityDamageByEntityEvent event){
  BukkitLocation location=new BukkitLocation(event.getDamager().getLocation());
  if (api.getPlotMeCoreManager().isPlotWorld(location)) {
    BukkitEntity entityDamaged=new BukkitEntity(event.getEntity());
    if (event.getDamager() instanceof Player) {
      Player player=(Player)event.getDamager();
      BukkitPlayer bukkitPlayer=new BukkitPlayer(player);
      boolean cantbuild=!player.hasPermission(PermissionNames.ADMIN_BUILDANYWHERE);
      String id=PlotMeCoreManager.getPlotId(location);
      if (id.isEmpty()) {
        if (cantbuild) {
          player.sendMessage(api.getUtil().C("String_Node_Str"));
          event.setCancelled(true);
        }
      }
 else {
        Plot plot=api.getPlotMeCoreManager().getPlotById(id,bukkitPlayer);
        if (plot == null) {
          if (cantbuild) {
            bukkitPlayer.sendMessage(api.getUtil().C("String_Node_Str"));
            event.setCancelled(true);
          }
        }
 else         if (!plot.isAllowed(player.getName(),player.getUniqueId())) {
          if (cantbuild) {
            bukkitPlayer.sendMessage(api.getUtil().C("String_Node_Str"));
            event.setCancelled(true);
          }
        }
      }
    }
 else {
      event.setCancelled(true);
    }
  }
}

Fixed version (ground truth):
@EventHandler public void onEntityDamagebyEntity(EntityDamageByEntityEvent event){
  BukkitLocation location=new BukkitLocation(event.getDamager().getLocation());
  if (api.getPlotMeCoreManager().isPlotWorld(location)) {
    if (event.getDamager() instanceof Player) {
      Player player=(Player)event.getDamager();
      BukkitPlayer bukkitPlayer=new BukkitPlayer(player);
      boolean cantbuild=!player.hasPermission(PermissionNames.ADMIN_BUILDANYWHERE);
      String id=PlotMeCoreManager.getPlotId(location);
      if (id.isEmpty()) {
        if (cantbuild) {
          player.sendMessage(api.getUtil().C("String_Node_Str"));
          event.setCancelled(true);
        }
      }
 else {
        Plot plot=api.getPlotMeCoreManager().getPlotById(id,bukkitPlayer);
        if (plot == null) {
          if (cantbuild) {
            bukkitPlayer.sendMessage(api.getUtil().C("String_Node_Str"));
            event.setCancelled(true);
          }
        }
 else         if (!plot.isAllowed(player.getName(),player.getUniqueId())) {
          if (cantbuild) {
            bukkitPlayer.sendMessage(api.getUtil().C("String_Node_Str"));
            event.setCancelled(true);
          }
        }
      }
    }
 else {
      event.setCancelled(true);
    }
  }
}
Program: 42093
Project: 42093
Buggy source:
@EventHandler public void onPlotWorldLoad(PlotWorldLoadEvent event){
  plugin.getLogger().info("String_Node_Str" + event.getNbPlots() + "String_Node_Str"+ event.getWorldName());
}

Fixed version (ground truth):
@EventHandler public void onPlotWorldLoad(PlotWorldLoadEvent event){
  api.getLogger().info("String_Node_Str" + event.getNbPlots() + "String_Node_Str"+ event.getWorldName());
}
Program: 42094
Project: 42094
Buggy source:
@EventHandler(priority=EventPriority.HIGH,ignoreCancelled=true) public void onBlockFromTo(BlockFromToEvent event){
  BukkitBlock block=new BukkitBlock(event.getBlock());
  if (api.getPlotMeCoreManager().isPlotWorld(block)) {
    String id=PlotMeCoreManager.getPlotId(block.getLocation());
    if (id.isEmpty()) {
      event.setCancelled(true);
    }
 else {
      PlotToClear ptc=api.getPlotLocked(block.getWorld().getName(),id);
      if (ptc != null) {
        event.setCancelled(true);
      }
    }
  }
}

Fixed version (ground truth):
@EventHandler(priority=EventPriority.HIGH,ignoreCancelled=true) public void onBlockFromTo(BlockFromToEvent event){
  BukkitBlock block=new BukkitBlock(event.getToBlock());
  if (api.getPlotMeCoreManager().isPlotWorld(block)) {
    String id=PlotMeCoreManager.getPlotId(block.getLocation());
    String id2=PlotMeCoreManager.getPlotId(block.getLocation());
    if (id2.isEmpty()) {
      event.setCancelled(true);
    }
    if (id.isEmpty()) {
      event.setCancelled(true);
    }
 else {
      PlotToClear ptc=api.getPlotLocked(block.getWorld().getName(),id);
      if (ptc != null) {
        event.setCancelled(true);
      }
    }
  }
}
Program: 42095
Project: 42095
Buggy source:
@EventHandler(priority=EventPriority.HIGH,ignoreCancelled=true) public void onBlockIgnite(BlockIgniteEvent event){
  BukkitEntity entity=new BukkitEntity(event.getIgnitingEntity());
  PlotMapInfo pmi=api.getPlotMeCoreManager().getMap(entity.getLocation());
  if (pmi != null) {
    if (pmi.isDisableIgnition()) {
      event.setCancelled(true);
    }
 else {
      String id=PlotMeCoreManager.getPlotId(entity.getLocation());
      if (id.isEmpty()) {
        event.setCancelled(true);
      }
 else {
        PlotToClear ptc=api.getPlotLocked(entity.getLocation().getWorld().getName(),id);
        Player player=null;
        if (ptc != null) {
          if (event.getPlayer() != null) {
            player=event.getPlayer();
switch (ptc.getReason()) {
case Clear:
              player.sendMessage(api.getUtil().C("String_Node_Str"));
            break;
case Reset:
          player.sendMessage(api.getUtil().C("String_Node_Str"));
        break;
case Expired:
      player.sendMessage(api.getUtil().C("String_Node_Str"));
    break;
}
}
event.setCancelled(true);
}
 else {
if (event.getPlayer() != null) {
player=event.getPlayer();
}
Plot plot=PlotMeCoreManager.getPlotById(id,pmi);
if (plot == null) {
event.setCancelled(true);
}
 else {
if (player != null && !plot.isAllowed(player.getName(),entity.getUniqueId())) {
  event.setCancelled(true);
}
}
}
}
}
}
}

Fixed version (ground truth):
@EventHandler(priority=EventPriority.HIGH,ignoreCancelled=true) public void onBlockIgnite(BlockIgniteEvent event){
  BukkitBlock block=new BukkitBlock(event.getBlock());
  PlotMapInfo pmi=api.getPlotMeCoreManager().getMap(block.getLocation());
  if (pmi != null) {
    if (pmi.isDisableIgnition()) {
      event.setCancelled(true);
    }
 else {
      String id=PlotMeCoreManager.getPlotId(block.getLocation());
      if (id.isEmpty()) {
        event.setCancelled(true);
      }
 else {
        PlotToClear ptc=api.getPlotLocked(block.getLocation().getWorld().getName(),id);
        Player player=null;
        if (ptc != null) {
          if (event.getPlayer() != null) {
            player=event.getPlayer();
switch (ptc.getReason()) {
case Clear:
              player.sendMessage(api.getUtil().C("String_Node_Str"));
            break;
case Reset:
          player.sendMessage(api.getUtil().C("String_Node_Str"));
        break;
case Expired:
      player.sendMessage(api.getUtil().C("String_Node_Str"));
    break;
}
}
event.setCancelled(true);
}
 else {
if (event.getPlayer() != null) {
player=event.getPlayer();
}
Plot plot=PlotMeCoreManager.getPlotById(id,pmi);
if (plot == null) {
event.setCancelled(true);
}
 else {
if (player != null && !plot.isAllowed(player.getName(),player.getUniqueId())) {
  event.setCancelled(true);
}
}
}
}
}
}
}
Program: 42096
Project: 42096
Buggy source:
/** 
 * hardcore math over here
 * @param x
 * @return
 */
private float getScoreForPosition(float x){
  if (mHalfStars)   return (float)Math.round(((x / ((float)getWidth() / (mMaxStars * 3f))) / 3f) * 2f) / 2;
  float value=(float)Math.round((x / ((float)getWidth() / (mMaxStars))));
  return value <= 0 ? 1 : value;
}

Fixed version (ground truth):
/** 
 * hardcore math over here
 * @param x
 * @return
 */
private float getScoreForPosition(float x){
  if (mHalfStars)   return (float)Math.round(((x / ((float)getWidth() / (mMaxStars * 3f))) / 3f) * 2f) / 2;
  float value=(float)Math.round((x / ((float)getWidth() / (mMaxStars))));
  return value < 0 ? 1 : value;
}
Program: 42097
Project: 42097
Buggy source:
public static void debug(Object info,Object... info2){
  if (isDeObf) {
    String temp="String_Node_Str" + info;
    for (    Object t : info2)     temp=temp + "String_Node_Str" + t;
    logger.info(info);
  }
}

Fixed version (ground truth):
public static void debug(Object info,Object... info2){
  if (isDeObf) {
    StringBuilder temp=new StringBuilder("String_Node_Str" + info);
    for (    Object t : info2)     temp.append("String_Node_Str").append(t);
    logger.info(temp.toString());
  }
}
Program: 42098
Project: 42098
Buggy source:
public static void error(Object info,Object... info2){
  String temp="String_Node_Str" + info;
  for (  Object t : info2)   temp=temp + "String_Node_Str" + t;
  logger.error(info);
}

Fixed version (ground truth):
public static void error(Object info,Object... info2){
  StringBuilder temp=new StringBuilder("String_Node_Str" + info);
  for (  Object t : info2)   temp.append("String_Node_Str").append(t);
  logger.error(temp.toString());
}
Program: 42099
Project: 42099
Buggy source:
public static void info(Object info,Object... info2){
  String temp="String_Node_Str" + info;
  for (  Object t : info2)   temp=temp + "String_Node_Str" + t;
  logger.info(info);
}

Fixed version (ground truth):
public static void info(Object info,Object... info2){
  StringBuilder temp=new StringBuilder("String_Node_Str" + info);
  for (  Object t : info2)   temp.append("String_Node_Str").append(t);
  logger.info(temp.toString());
}
Program: 42100
Project: 42100
Buggy source:
@Override public ItemStack getCraftingResult(InventoryCrafting var1){
  return ItemBlockTeleporter.assignRandomID(super.getCraftingResult(var1));
}

Fixed version (ground truth):
@Nonnull @Override public ItemStack getCraftingResult(@Nonnull InventoryCrafting var1){
  return ItemBlockTeleporter.assignRandomID(super.getCraftingResult(var1));
}
Program: 42102
Project: 42102
Buggy source:
@Nonnull @Override public IBlockState getStateForPlacement(World worldIn,BlockPos pos,EnumFacing facing,float hitX,float hitY,float hitZ,int meta,EntityLivingBase placer,EnumHand hand){
  IBlockState state=super.getStateForPlacement(worldIn,pos,facing,hitX,hitY,hitZ,meta,placer,hand);
  EnumFacing opposite=facing.getOpposite();
  if (worldIn.getTileEntity(pos.offset(opposite)) instanceof IMover) {
    return state.withProperty(BlockDirectional.FACING,opposite);
  }
  for (  EnumFacing enumFacing : EnumFacing.values()) {
    if (worldIn.getTileEntity(pos.offset(enumFacing)) instanceof IMover) {
      return state.withProperty(BlockDirectional.FACING,enumFacing);
    }
  }
  return state.withProperty(BlockDirectional.FACING,opposite);
}

Fixed version (ground truth):
@Nonnull @Override public IBlockState getStateForPlacement(@Nonnull World worldIn,@Nonnull BlockPos pos,@Nonnull EnumFacing facing,float hitX,float hitY,float hitZ,int meta,@Nonnull EntityLivingBase placer,EnumHand hand){
  IBlockState state=super.getStateForPlacement(worldIn,pos,facing,hitX,hitY,hitZ,meta,placer,hand);
  EnumFacing opposite=facing.getOpposite();
  if (worldIn.getTileEntity(pos.offset(opposite)) instanceof IMover) {
    return state.withProperty(BlockDirectional.FACING,opposite);
  }
  for (  EnumFacing enumFacing : EnumFacing.values()) {
    if (worldIn.getTileEntity(pos.offset(enumFacing)) instanceof IMover) {
      return state.withProperty(BlockDirectional.FACING,enumFacing);
    }
  }
  return state.withProperty(BlockDirectional.FACING,opposite);
}
Program: 42103
Project: 42103
Buggy source:
@Override public abstract IBlockState getStateFromMeta(int meta);

Fixed version (ground truth):
@Nonnull @Override public abstract IBlockState getStateFromMeta(int meta);
Program: 42104
Project: 42104
Buggy source:
@Override public AxisAlignedBB getBoundingBox(IBlockState state,IBlockAccess source,BlockPos pos){
  return bounds;
}

Fixed version (ground truth):
@Nonnull @Override public AxisAlignedBB getBoundingBox(IBlockState state,IBlockAccess source,BlockPos pos){
  return bounds;
}
Program: 42105
Project: 42105
Buggy source:
@Override public void breakBlock(World worldIn,BlockPos pos,IBlockState state){
  super.breakBlock(worldIn,pos,state);
}

Fixed version (ground truth):
@Override public void breakBlock(@Nonnull World worldIn,@Nonnull BlockPos pos,@Nonnull IBlockState state){
  super.breakBlock(worldIn,pos,state);
}
Program: 42106
Project: 42106
Buggy source:
@Override public BlockFaceShape getBlockFaceShape(IBlockAccess blockAccess,IBlockState stateIn,BlockPos pos,EnumFacing side){
  return BlockFaceShape.UNDEFINED;
}

Fixed version (ground truth):
@Nonnull @Override public BlockFaceShape getBlockFaceShape(IBlockAccess blockAccess,IBlockState stateIn,BlockPos pos,EnumFacing side){
  return BlockFaceShape.UNDEFINED;
}
Program: 42107
Project: 42107
Buggy source:
@Nullable @Override public ItemStack getItem(World worldIn,BlockPos pos,@Nonnull IBlockState state){
  @SuppressWarnings("String_Node_Str") ItemStack item=super.getItem(worldIn,pos,state);
  if (item.isEmpty() == false) {
    TileEntity tileEntity=worldIn.getTileEntity(pos);
    if (tileEntity instanceof TileTeleport) {
      int teleportId=((TileTeleport)tileEntity).teleportId;
      if (teleportId != 0) {
        NBTTagCompound tag=new NBTTagCompound();
        tag.setInteger(ItemBlockTeleporter.NBT_TELEPORTER_ID,teleportId);
        item.setTagCompound(tag);
      }
    }
  }
  return item;
}

Fixed version (ground truth):
@Override public ItemStack getItem(World worldIn,BlockPos pos,@Nonnull IBlockState state){
  @SuppressWarnings("String_Node_Str") ItemStack item=super.getItem(worldIn,pos,state);
  if (!item.isEmpty()) {
    TileEntity tileEntity=worldIn.getTileEntity(pos);
    if (tileEntity instanceof TileTeleport) {
      int teleportId=((TileTeleport)tileEntity).teleportId;
      if (teleportId != 0) {
        NBTTagCompound tag=new NBTTagCompound();
        tag.setInteger(ItemBlockTeleporter.NBT_TELEPORTER_ID,teleportId);
        item.setTagCompound(tag);
      }
    }
  }
  return item;
}
Program: 42108
Project: 42108
Buggy source:
@Override public boolean shouldRefresh(World world,BlockPos pos,IBlockState oldState,IBlockState newSate){
  return oldState.getBlock() != newSate.getBlock();
}

Fixed version (ground truth):
@Override public boolean shouldRefresh(World world,BlockPos pos,@Nonnull IBlockState oldState,@Nonnull IBlockState newSate){
  return oldState.getBlock() != newSate.getBlock();
}
Program: 42109
Project: 42109
Buggy source:
@Override public void update(){
  if (maxTime == 0)   return;
  if (getWorld().isRemote) {
    time=time + 1 - 1;
  }
  Vec3d mov=getMovVec();
  Set<Entity> entityList=new HashSet<>();
  time++;
  for (  AxisAlignedBB bb : getTransformedColisions()) {
    List<Entity> entities=getWorld().getEntitiesWithinAABB(Entity.class,bb.expand(0,0.1,0));
    for (    Entity entity : entities) {
      entityList.add(entity);
    }
  }
  for (  Entity a : entityList) {
    if (!a.isDead) {
      Map<Entity,Vec3d> map=EntityMovingEventHandler.getMovementMap(side);
      if (!map.containsKey(a)) {
        for (        AxisAlignedBB bb : getTransformedColisions()) {
          AxisAlignedBB boundingBox=a.getEntityBoundingBox();
          if (boundingBox.intersects(bb)) {
            if (boundingBox.minY > bb.maxY - 0.2) {
              a.setEntityBoundingBox(boundingBox.offset(0,bb.maxY - boundingBox.minY,0));
            }
          }
 else           if (dir == 0 && a.motionY <= 0 && boundingBox.intersects(bb.offset(0,0.2,0))) {
            a.setEntityBoundingBox(boundingBox.offset(0,bb.maxY - boundingBox.minY,0));
          }
        }
        EntityMovingEventHandler.moveEntity(a,mov.x,mov.y,mov.z);
        map.put(a,null);
      }
    }
  }
}

Fixed version (ground truth):
@Override public void update(){
  if (maxTime == 0)   return;
  if (getWorld().isRemote) {
    time=time + 1 - 1;
  }
  Vec3d mov=getMovVec();
  Set<Entity> entityList=new HashSet<>();
  time++;
  for (  AxisAlignedBB bb : getTransformedColisions()) {
    List<Entity> entities=getWorld().getEntitiesWithinAABB(Entity.class,bb.expand(0,0.1,0));
    entityList.addAll(entities);
  }
  for (  Entity a : entityList) {
    if (!a.isDead) {
      Map<Entity,Vec3d> map=EntityMovingEventHandler.getMovementMap(side);
      if (!map.containsKey(a)) {
        for (        AxisAlignedBB bb : getTransformedColisions()) {
          AxisAlignedBB boundingBox=a.getEntityBoundingBox();
          if (boundingBox.intersects(bb)) {
            if (boundingBox.minY > bb.maxY - 0.2) {
              a.setEntityBoundingBox(boundingBox.offset(0,bb.maxY - boundingBox.minY,0));
            }
          }
 else           if (dir == 0 && a.motionY <= 0 && boundingBox.intersects(bb.offset(0,0.2,0))) {
            a.setEntityBoundingBox(boundingBox.offset(0,bb.maxY - boundingBox.minY,0));
          }
        }
        EntityMovingEventHandler.moveEntity(a,mov.x,mov.y,mov.z);
        map.put(a,null);
      }
    }
  }
}
Program: 42110
Project: 42110
Buggy source:
@Override public void handleUpdateTag(NBTTagCompound tag){
  block=Block.getBlockById(tag.getInteger("String_Node_Str"));
  meta=tag.getInteger("String_Node_Str");
  time=tag.getInteger("String_Node_Str");
  maxTime=tag.getInteger("String_Node_Str");
  lightLevel=tag.getInteger("String_Node_Str");
  lightOpacity=tag.getShort("String_Node_Str");
  isAir=block == Blocks.AIR;
  if (tag.hasKey("String_Node_Str",9)) {
    collisions=AxisTags(tag.getTagList("String_Node_Str",10));
  }
  dir=tag.getByte("String_Node_Str");
  TileEntity tile=null;
  if (this.dir >= 0 && this.dir < 8 && this.dir != 6) {
    EnumFacing d=getDir();
    WeakReference<TileEntity> ref=cachedTiles.remove(d != null ? pos.offset(d,-1) : pos);
  }
  if (tile != null && FakeWorldClient.isValid(getWorld()) && tile.getWorld() == this.getWorld()) {
    rawTile=true;
    tile.setPos(pos.toImmutable());
    tile.setWorld(FakeWorldClient.getFakeWorldWrapper(this.getWorld()));
    tile.updateContainingBlockInfo();
    this.tile=tile;
    render=true;
  }
 else {
    render=!tag.getBoolean("String_Node_Str");
    if (render) {
      this.tile=Describer.recreateTileEntity(tag,getState(),pos,FakeWorldClient.getFakeWorldWrapper(this.getWorld()));
    }
  }
  if (checkClass(this.block) || checkClass(this.tile))   this.tile=null;
  if (render && !init)   ChunkRerenderer.markBlock(pos);
  init=true;
  getWorld().markBlockRangeForRenderUpdate(pos,pos);
}

Fixed version (ground truth):
@Override public void handleUpdateTag(@Nonnull NBTTagCompound tag){
  block=Block.getBlockById(tag.getInteger("String_Node_Str"));
  meta=tag.getInteger("String_Node_Str");
  time=tag.getInteger("String_Node_Str");
  maxTime=tag.getInteger("String_Node_Str");
  lightLevel=tag.getInteger("String_Node_Str");
  lightOpacity=tag.getShort("String_Node_Str");
  isAir=block == Blocks.AIR;
  if (tag.hasKey("String_Node_Str",9)) {
    collisions=AxisTags(tag.getTagList("String_Node_Str",10));
  }
  dir=tag.getByte("String_Node_Str");
  TileEntity tile=null;
  if (this.dir >= 0 && this.dir < 8 && this.dir != 6) {
    EnumFacing d=getDir();
    WeakReference<TileEntity> ref=cachedTiles.remove(d != null ? pos.offset(d,-1) : pos);
  }
  if (tile != null && FakeWorldClient.isValid(getWorld()) && tile.getWorld() == this.getWorld()) {
    rawTile=true;
    tile.setPos(pos.toImmutable());
    tile.setWorld(FakeWorldClient.getFakeWorldWrapper(this.getWorld()));
    tile.updateContainingBlockInfo();
    this.tile=tile;
    render=true;
  }
 else {
    render=!tag.getBoolean("String_Node_Str");
    if (render) {
      this.tile=Describer.recreateTileEntity(tag,getState(),pos,FakeWorldClient.getFakeWorldWrapper(this.getWorld()));
    }
  }
  if (checkClass(this.block) || checkClass(this.tile))   this.tile=null;
  if (render && !init)   ChunkRerenderer.markBlock(pos);
  init=true;
  getWorld().markBlockRangeForRenderUpdate(pos,pos);
}
Program: 42111
Project: 42111
Buggy source:
@Override public boolean hasCapability(@Nonnull Capability<?> capability,@Nonnull EnumFacing facing){
  return (capability == CapabilityEnergy.ENERGY && TilePusher.powerPerTile > 0) || super.hasCapability(capability,facing);
}

Fixed version (ground truth):
@Override public boolean hasCapability(@Nonnull Capability<?> capability,EnumFacing facing){
  return (capability == CapabilityEnergy.ENERGY && TilePusher.powerPerTile > 0) || super.hasCapability(capability,facing);
}
Program: 42112
Project: 42112
Buggy source:
@Nonnull @Override public <T>T getCapability(@Nonnull Capability<T> capability,@Nonnull EnumFacing facing){
  if (capability == CapabilityEnergy.ENERGY && TilePusher.powerPerTile > 0) {
    return CapabilityEnergy.ENERGY.cast(public_energy_wrapper);
  }
  return super.getCapability(capability,facing);
}

Fixed version (ground truth):
@Override public <T>T getCapability(@Nonnull Capability<T> capability,EnumFacing facing){
  if (capability == CapabilityEnergy.ENERGY && TilePusher.powerPerTile > 0) {
    return CapabilityEnergy.ENERGY.cast(public_energy_wrapper);
  }
  return super.getCapability(capability,facing);
}
Program: 42114
Project: 42114
Buggy source:
@Override public NBTTagCompound destroyBlock(World world,BlockPos pos){
  NBTTagCompound tag=new NBTTagCompound();
  TileEntity te=world.getTileEntity(pos);
  if (te != null && te instanceof TileMultipart) {
    TileMultipart multipart=(TileMultipart)te;
    multipart.writeToNBT(tag);
  }
  tag.merge(defaultFactory.destroyBlock(world,pos));
  return tag;
}

Fixed version (ground truth):
@Override public NBTTagCompound destroyBlock(World world,BlockPos pos){
  NBTTagCompound tag=new NBTTagCompound();
  TileEntity te=world.getTileEntity(pos);
  if (te instanceof TileMultipart) {
    TileMultipart multipart=(TileMultipart)te;
    multipart.writeToNBT(tag);
  }
  tag.merge(defaultFactory.destroyBlock(world,pos));
  return tag;
}
Program: 42115
Project: 42115
Buggy source:
@Override public ItemStack dispenseStack(IBlockSource pos,ItemStack stack){
  return stack;
}

Fixed version (ground truth):
@Nonnull @Override public ItemStack dispenseStack(IBlockSource pos,ItemStack stack){
  return stack;
}
Program: 42116
Project: 42116
Buggy source:
@Override public ItemStack dispenseStack(IBlockSource pos,ItemStack stack){
  return stack;
}

Fixed version (ground truth):
@Nonnull @Override public ItemStack dispenseStack(IBlockSource pos,ItemStack stack){
  return stack;
}
Program: 42117
Project: 42117
Buggy source:
@Override public TileEntity getTileEntity(BlockPos pos){
  TileEntity tileEntity=tileOverides.get(pos);
  if (tileEntity != null)   return tileEntity;
  TileMovingClient tileMovingClient=getTile(pos);
  return tileMovingClient == null ? null : tileMovingClient.tile;
}

Fixed version (ground truth):
@Override public TileEntity getTileEntity(@Nonnull BlockPos pos){
  TileEntity tileEntity=tileOverides.get(pos);
  if (tileEntity != null)   return tileEntity;
  TileMovingClient tileMovingClient=getTile(pos);
  return tileMovingClient == null ? null : tileMovingClient.tile;
}
Program: 42118
Project: 42118
Buggy source:
@Override public boolean setBlockState(BlockPos pos,@Nonnull IBlockState newState,int flags){
  return false;
}

Fixed version (ground truth):
@Override public boolean setBlockState(@Nonnull BlockPos pos,@Nonnull IBlockState newState,int flags){
  return false;
}
Program: 42119
Project: 42119
Buggy source:
@Override public boolean isSideSolid(BlockPos pos,@Nonnull EnumFacing side,boolean _default){
  return this.getBlockState(pos).isSideSolid(this,pos,side);
}

Fixed version (ground truth):
@Override public boolean isSideSolid(@Nonnull BlockPos pos,@Nonnull EnumFacing side,boolean _default){
  return this.getBlockState(pos).isSideSolid(this,pos,side);
}
Program: 42120
Project: 42120
Buggy source:
@Nonnull @Override public IBlockState getBlockState(BlockPos pos){
  IBlockState state=blockstateOverides.get(pos);
  if (state != null)   return state;
  TileMovingClient tile=getTile(pos);
  if (tile != null)   return tile.getState();
  return BlockStates.AIR;
}

Fixed version (ground truth):
@Nonnull @Override public IBlockState getBlockState(@Nonnull BlockPos pos){
  IBlockState state=blockstateOverides.get(pos);
  if (state != null)   return state;
  TileMovingClient tile=getTile(pos);
  if (tile != null)   return tile.getState();
  return BlockStates.AIR;
}
Program: 42121
Project: 42121
Buggy source:
@Override public boolean isBlockNormalCube(BlockPos pos,boolean _default){
  IBlockState state=getBlockState(pos);
  return state.getBlock().isNormalCube(state,this,pos);
}

Fixed version (ground truth):
@Override public boolean isBlockNormalCube(@Nonnull BlockPos pos,boolean _default){
  IBlockState state=getBlockState(pos);
  return state.getBlock().isNormalCube(state,this,pos);
}
Program: 42122
Project: 42122
Buggy source:
@Override @Nullable public TileEntity getTileEntity(BlockPos pos){
  return access.getTileEntity(pos.add(offset));
}

Fixed version (ground truth):
@Override @Nullable public TileEntity getTileEntity(@Nonnull BlockPos pos){
  return access.getTileEntity(pos.add(offset));
}
Program: 42123
Project: 42123
Buggy source:
@Override @SideOnly(Side.CLIENT) public int getCombinedLight(BlockPos pos,int lightValue){
  return access.getCombinedLight(pos.add(offset),lightValue);
}

Fixed version (ground truth):
@Override @SideOnly(Side.CLIENT) public int getCombinedLight(@Nonnull BlockPos pos,int lightValue){
  return access.getCombinedLight(pos.add(offset),lightValue);
}
Program: 42124
Project: 42124
Buggy source:
@Override public boolean isAirBlock(BlockPos pos){
  return access.isAirBlock(pos.add(offset));
}

Fixed version (ground truth):
@Override public boolean isAirBlock(@Nonnull BlockPos pos){
  return access.isAirBlock(pos.add(offset));
}
Program: 42125
Project: 42125
Buggy source:
@Override public int getStrongPower(BlockPos pos,EnumFacing direction){
  return access.getStrongPower(pos.add(offset),direction);
}

Fixed version (ground truth):
@Override public int getStrongPower(@Nonnull BlockPos pos,@Nonnull EnumFacing direction){
  return access.getStrongPower(pos.add(offset),direction);
}
Program: 42126
Project: 42126
Buggy source:
@Override public IBlockState getBlockState(BlockPos pos){
  return access.getBlockState(pos.add(offset));
}

Fixed version (ground truth):
@Nonnull @Override public IBlockState getBlockState(@Nonnull BlockPos pos){
  return access.getBlockState(pos.add(offset));
}
Program: 42127
Project: 42127
Buggy source:
@Override @SideOnly(Side.CLIENT) public WorldType getWorldType(){
  return access.getWorldType();
}

Fixed version (ground truth):
@Nonnull @Override @SideOnly(Side.CLIENT) public WorldType getWorldType(){
  return access.getWorldType();
}
Program: 42128
Project: 42128
Buggy source:
@Override @SideOnly(Side.CLIENT) public Biome getBiome(BlockPos pos){
  return access.getBiome(pos.add(offset));
}

Fixed version (ground truth):
@Nonnull @Override @SideOnly(Side.CLIENT) public Biome getBiome(@Nonnull BlockPos pos){
  return access.getBiome(pos.add(offset));
}
Program: 42129
Project: 42129
Buggy source:
@Override public boolean isSideSolid(BlockPos pos,EnumFacing side,boolean _default){
  return access.isSideSolid(pos.add(offset),side,_default);
}

Fixed version (ground truth):
@Override public boolean isSideSolid(@Nonnull BlockPos pos,@Nonnull EnumFacing side,boolean _default){
  return access.isSideSolid(pos.add(offset),side,_default);
}
Program: 42131
Project: 42131
Buggy source:
@SuppressWarnings("String_Node_Str") public static boolean silentSetBlock(Chunk chunk,BlockPos pos,Block block,int meta){
  int dx=pos.getX() & 15;
  int dz=pos.getZ() & 15;
  int y=pos.getY();
  int i1=dz << 4 | dx;
  try {
    int[] precMap=(int[])field_Chunk_precipitationHeightMap.get(chunk);
    if (y >= precMap[i1] - 1) {
      precMap[i1]=-999;
    }
  }
 catch (  Exception e) {
  }
  IBlockState state1=chunk.getBlockState(dx,y,dz);
  Block block1=state1.getBlock();
  int k1=block1.getMetaFromState(state1);
  if (block1 == block && k1 == meta) {
    return false;
  }
 else {
    ExtendedBlockStorage extendedblockstorage=chunk.getBlockStorageArray()[y >> 4];
    if (extendedblockstorage == Chunk.NULL_BLOCK_STORAGE) {
      if (block == Blocks.AIR) {
        return false;
      }
      extendedblockstorage=chunk.getBlockStorageArray()[y >> 4]=new ExtendedBlockStorage(y >> 4 << 4,!chunk.getWorld().provider.isNether());
    }
    extendedblockstorage.set(dx,y & 15,dz,block.getStateFromMeta(meta));
    chunk.setModified(true);
    return true;
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public static boolean silentSetBlock(Chunk chunk,BlockPos pos,Block block,int meta){
  int dx=pos.getX() & 15;
  int dz=pos.getZ() & 15;
  int y=pos.getY();
  int i1=dz << 4 | dx;
  try {
    int[] precMap=(int[])field_Chunk_precipitationHeightMap.get(chunk);
    if (y >= precMap[i1] - 1) {
      precMap[i1]=-999;
    }
  }
 catch (  IllegalAccessException e) {
    throw new RuntimeException(e);
  }
  IBlockState state1=chunk.getBlockState(dx,y,dz);
  Block block1=state1.getBlock();
  int k1=block1.getMetaFromState(state1);
  if (block1 == block && k1 == meta) {
    return false;
  }
 else {
    ExtendedBlockStorage extendedblockstorage=chunk.getBlockStorageArray()[y >> 4];
    if (extendedblockstorage == Chunk.NULL_BLOCK_STORAGE) {
      if (block == Blocks.AIR) {
        return false;
      }
      extendedblockstorage=chunk.getBlockStorageArray()[y >> 4]=new ExtendedBlockStorage(y >> 4 << 4,!chunk.getWorld().provider.isNether());
    }
    extendedblockstorage.set(dx,y & 15,dz,block.getStateFromMeta(meta));
    chunk.setModified(true);
    return true;
  }
}
Program: 42132
Project: 42132
Buggy source:
public static <E>MethodHandle getMethodHandleVirtual(Class<? super E> clazz,String[] methodNames,Class<?>... paramTypes){
  Exception failed=null;
  try {
    Method method=reflectMethod(clazz,methodNames,paramTypes);
    MethodHandle handle=MethodHandles.lookup().unreflect(method);
    method.setAccessible(false);
    return handle;
  }
 catch (  IllegalAccessException e) {
    failed=e;
  }
  throw new UnableToFindMethodHandleException(methodNames,failed);
}

Fixed version (ground truth):
public static <E>MethodHandle getMethodHandleVirtual(Class<? super E> clazz,String[] methodNames,Class<?>... paramTypes){
  Exception failed;
  try {
    Method method=reflectMethod(clazz,methodNames,paramTypes);
    MethodHandle handle=MethodHandles.lookup().unreflect(method);
    method.setAccessible(false);
    return handle;
  }
 catch (  IllegalAccessException e) {
    failed=e;
  }
  throw new UnableToFindMethodHandleException(methodNames,failed);
}
Program: 42133
Project: 42133
Buggy source:
@SubscribeEvent public static void registerItems(RegistryEvent.Register<Item> event){
  IForgeRegistry<Item> registry=event.getRegistry();
  registry.register(generateItemBlock(FLBlocks.BOOSTER));
  registry.register(generateItemBlock(FLBlocks.FRAME_PROJECTOR));
  registry.register(new ItemBlockPusher(FLBlocks.PUSHER).setRegistryName(FLBlocks.PUSHER.getRegistryName()));
  registry.register(generateItemBlock(FLBlocks.SLIDER));
  registry.register(new ItemBlockTeleporter(FLBlocks.TELEPORTER).setRegistryName(FLBlocks.TELEPORTER.getRegistryName()));
  registry.register(generateItemBlock(FLBlocks.MASS_FRAME_EDGE));
  registry.register(generateItemBlock(FLBlocks.MASS_FRAME_CORNER));
  for (int i=0; i < 4; i++) {
    registry.register(generateItemBlock(FLBlocks.FRAMES[i]));
  }
  registry.register(WrenchFactory.makeMeAWrench());
}

Fixed version (ground truth):
@SubscribeEvent public static void registerItems(RegistryEvent.Register<Item> event){
  IForgeRegistry<Item> registry=event.getRegistry();
  registry.register(generateItemBlock(FLBlocks.BOOSTER));
  registry.register(generateItemBlock(FLBlocks.FRAME_PROJECTOR));
  registry.register(new ItemBlockPusher(FLBlocks.PUSHER).setRegistryName(FLBlocks.PUSHER.getRegistryName()));
  registry.register(generateItemBlock(FLBlocks.SLIDER));
  registry.register(new ItemBlockTeleporter(FLBlocks.TELEPORTER).setRegistryName(FLBlocks.TELEPORTER.getRegistryName()));
  registry.register(generateItemBlock(FLBlocks.MASS_FRAME_EDGE));
  registry.register(generateItemBlock(FLBlocks.MASS_FRAME_CORNER));
  for (int i=0; i < 4; i++) {
    registry.register(new ItemBlockFrame(FLBlocks.FRAMES[i]).setRegistryName(FLBlocks.FRAMES[i].getRegistryName()));
  }
  registry.register(WrenchFactory.makeMeAWrench());
}
Program: 42134
Project: 42134
Buggy source:
/** 
 * Start a twitter client instance
 */
public void initTwitter(){
  twClient=new TwitterFactory().getInstance();
  twClient.setOAuthConsumer(Config.CONSUMER_KEY,Config.CONSUMER_SECRET);
}

Fixed version (ground truth):
public void initTwitter(){
  twClient=new TwitterFactory().getInstance();
  twClient.setOAuthConsumer(Config.CONSUMER_KEY,Config.CONSUMER_SECRET);
}
Program: 42135
Project: 42135
Buggy source:
@Override protected void onPostExecute(Boolean operationSuccessfully){
  super.onPostExecute(operationSuccessfully);
  twitterListener.onTwitterOperationSuccess(isARetweet);
}

Fixed version (ground truth):
@Override protected void onPostExecute(Boolean operationSuccessfully){
  super.onPostExecute(operationSuccessfully);
  twitterListener.onTwitterOperationSuccess(operationSuccessfully);
}
Program: 42136
Project: 42136
Buggy source:
@Override public void onMessageReceived(MessageEvent messageEvent){
  super.onMessageReceived(messageEvent);
  String msg=messageEvent.getPath();
  if (msg.equals(Constants.MSG_SALUDATE)) {
    new RequestConnectedNodes().execute();
  }
  if (msg.equals(Constants.MSG_LOAD_LAST_TIMELINE)) {
    twHelper.requestTwitterTimeLine(twitterListener);
  }
 else   if (msg.startsWith(Constants.MSG_RETWEET)) {
    String twID=msg.split("String_Node_Str")[3];
    twHelper.retweet(twID);
  }
 else   if (msg.startsWith(Constants.MSG_FAVORITE)) {
    String twID=msg.split("String_Node_Str")[3];
    twHelper.markTweetAsFavorite(twID);
  }
}

Fixed version (ground truth):
@Override public void onMessageReceived(MessageEvent messageEvent){
  super.onMessageReceived(messageEvent);
  String msg=messageEvent.getPath();
  if (msg.equals(Constants.MSG_SALUDATE)) {
    sendMessageToWearable(Constants.MSG_AVAILABLE);
  }
  if (msg.equals(Constants.MSG_LOAD_LAST_TIMELINE)) {
    twHelper.requestTwitterTimeLine(twitterListener);
  }
 else   if (msg.startsWith(Constants.MSG_RETWEET)) {
    String twID=msg.split("String_Node_Str")[3];
    twHelper.retweet(twID);
  }
 else   if (msg.startsWith(Constants.MSG_FAVORITE)) {
    String twID=msg.split("String_Node_Str")[3];
    twHelper.markTweetAsFavorite(twID);
  }
}
Program: 42137
Project: 42137
Buggy source:
public void sendMessageToWearable(String message){
  Log.d("String_Node_Str","String_Node_Str" + (connectedNode == null));
  new SendMessageTask(message,googleApiClient,connectedNode).execute();
}

Fixed version (ground truth):
public void sendMessageToWearable(String message){
  new SendMessageTask(message,googleApiClient,connectedNode).execute();
}
Program: 42138
Project: 42138
Buggy source:
@Override public Fragment getFragment(int row,int column){
  Tweet currentTweet=tweets.get(row);
  TwitterActionFragment twitterActionFragment=new TwitterActionFragment();
  if (column == 0) {
    TweetFragment tf=new TweetFragment();
    tf.setCardTweet(currentTweet);
    return tf;
  }
 else   if (column == 1) {
    twitterActionFragment.setTwAction(TwitterAction.RETWEET);
  }
 else   if (column == 2) {
    twitterActionFragment.setTwAction(TwitterAction.FAVORITE);
  }
  twitterActionFragment.setCurrentTweet(currentTweet);
  return twitterActionFragment;
}

Fixed version (ground truth):
@Override public Fragment getFragment(int row,int column){
  Tweet currentTweet=tweets.get(row);
  TwitterActionFragment twitterActionFragment=new TwitterActionFragment();
  twitterActionFragment.setPagerListener(pListener);
  pagerRow=row;
  if (column == 0) {
    TweetFragment tf=new TweetFragment();
    tf.setCardTweet(currentTweet);
    return tf;
  }
 else   if (column == 1) {
    twitterActionFragment.setTwAction(TwitterAction.RETWEET);
  }
 else   if (column == 2) {
    twitterActionFragment.setTwAction(TwitterAction.FAVORITE);
  }
  twitterActionFragment.setCurrentTweet(currentTweet);
  return twitterActionFragment;
}
Program: 42139
Project: 42139
Buggy source:
private void initUI(){
  setContentView(R.layout.activity_wait);
  stateMessageTV=(TextView)findViewById(R.id.loading_textview);
  loadingFL=(FrameLayout)findViewById(R.id.loading_frame);
  loadingSegment=(ImageView)findViewById(R.id.loading_segment);
  loadingSegment.startAnimation(AnimationUtils.loadAnimation(this,R.anim.loading_animation));
  printWelcomeMessage();
}

Fixed version (ground truth):
private void initUI(){
  setContentView(R.layout.activity_wait);
  stateMessageTV=(TextView)findViewById(R.id.loading_textview);
  loadingFL=(FrameLayout)findViewById(R.id.loading_frame);
  loadingSegment=(ImageView)findViewById(R.id.loading_segment);
  loadingSegment.startAnimation(AnimationUtils.loadAnimation(this,R.anim.loading_animation));
}
Program: 42140
Project: 42140
Buggy source:
@Override public void onWearReady(boolean connected){
  Log.d("String_Node_Str","String_Node_Str" + connected);
  if (connected)   handler.requestTwitterTimeline();
 else {
    showError("String_Node_Str");
  }
}

Fixed version (ground truth):
@Override public void onWearReady(boolean connected){
  if (connected)   handler.requestTwitterTimeline();
 else {
    showError("String_Node_Str");
  }
}
Program: 42141
Project: 42141
Buggy source:
@Override public void onTimeLimeReceived(ArrayList<String> timeline){
  d("String_Node_Str","String_Node_Str" + timeline.size());
  Intent streamIntent=new Intent(WaitActivity.this,StreamActivity.class);
  Bundle b=new Bundle();
  b.putStringArrayList("String_Node_Str",timeline);
  streamIntent.putExtras(b);
  startActivity(streamIntent);
  this.finish();
}

Fixed version (ground truth):
@Override public void onTimeLimeReceived(ArrayList<String> timeline){
  Intent streamIntent=new Intent(WaitActivity.this,StreamActivity.class);
  Bundle b=new Bundle();
  b.putStringArrayList("String_Node_Str",timeline);
  streamIntent.putExtras(b);
  startActivity(streamIntent);
  this.finish();
}
Program: 42142
Project: 42142
Buggy source:
@Nullable @Override public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState){
  View rootView=inflater.inflate(R.layout.tweet_fragment,null);
  TextView name=(TextView)rootView.findViewById(R.id.tf_name);
  TextView tweet=(TextView)rootView.findViewById(R.id.tf_tweet);
  TextView time=(TextView)rootView.findViewById(R.id.tf_time);
  if (cardTweet.getTweet().length() >= 120) {
    tweet.setTextSize(tweet.getTextSize() - 10);
    name.setTextSize(name.getTextSize() - 10);
  }
  SpannableString spannableContent=new SpannableString(cardTweet.getTweet());
  Matcher matcher2=MENTION_PATTERN.matcher(cardTweet.getTweet());
  while (matcher2.find()) {
    spannableContent.setSpan(new ForegroundColorSpan(getResources().getColor(R.color.wall_color)),matcher2.start(),matcher2.end(),Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
  Matcher matcher3=HASHTAG_PATTERN.matcher(cardTweet.getTweet());
  while (matcher3.find()) {
    spannableContent.setSpan(new ForegroundColorSpan(getResources().getColor(R.color.wall_color)),matcher3.start(),matcher3.end(),Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
  }
  name.setText(cardTweet.getName());
  tweet.setText(spannableContent);
  time.setText(cardTweet.getTime());
  return rootView;
}

Fixed version (ground truth):
@Nullable @Override public View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState){
  View rootView=inflater.inflate(R.layout.tweet_fragment,null);
  TextView name=(TextView)rootView.findViewById(R.id.tf_name);
  TextView tweet=(TextView)rootView.findViewById(R.id.tf_tweet);
  TextView time=(TextView)rootView.findViewById(R.id.tf_time);
  if (cardTweet.getTweet().length() >= 120) {
    tweet.setTextSize(tweet.getTextSize() - 10);
    name.setTextSize(name.getTextSize() - 10);
  }
  SpannableString spannableContent=new SpannableString(cardTweet.getTweet());
  Matcher mentionMatcher=MENTION_PATTERN.matcher(cardTweet.getTweet());
  setPatternSpan(mentionMatcher,spannableContent);
  Matcher hashtagMatcher=HASHTAG_PATTERN.matcher(cardTweet.getTweet());
  setPatternSpan(hashtagMatcher,spannableContent);
  name.setText(cardTweet.getName());
  tweet.setText(spannableContent);
  time.setText(cardTweet.getTime());
  return rootView;
}
Program: 42143
Project: 42143
Buggy source:
/** 
 * return an equivalent copy without epsilon moves
 */
protected SFT<P,F,S> removeEpsilonMoves(BooleanAlgebraSubst<P,F,S> ba){
  return removeEpsilonMovesFrom(this,ba);
}

Fixed version (ground truth):
/** 
 * return an equivalent copy without epsilon moves
 */
protected SFT<P,F,S> removeEpsilonMoves(BooleanAlgebraSubst<P,F,S> ba) throws TimeoutException {
  return removeEpsilonMovesFrom(this,ba);
}
Program: 42144
Project: 42144
Buggy source:
public static <P,F,S>SFT<P,F,S> MkSFT(Collection<SFTMove<P,F,S>> transitions,Integer initialState,Map<Integer,Set<List<S>>> finalStatesAndTails,BooleanAlgebraSubst<P,F,S> ba){
  SFT<P,F,S> aut=new SFT<P,F,S>();
  aut.initialState=initialState;
  for (  Integer state : finalStatesAndTails.keySet()) {
    Set<List<S>> tails=new HashSet<List<S>>();
    for (    List<S> tail : finalStatesAndTails.get(state)) {
      if (tail.size() != 0)       tails.add(tail);
    }
    aut.finalStatesAndTails.put(state,tails);
  }
  aut.states=new HashSet<Integer>();
  aut.states.add(initialState);
  aut.states.addAll(finalStatesAndTails.keySet());
  try {
    for (    SFTMove<P,F,S> t : transitions)     aut.addTransition(t,ba,false);
    return aut;
  }
 catch (  TimeoutException toe) {
    return null;
  }
}

Fixed version (ground truth):
public static <P,F,S>SFT<P,F,S> MkSFT(Collection<SFTMove<P,F,S>> transitions,Integer initialState,Map<Integer,Set<List<S>>> finalStatesAndTails,BooleanAlgebraSubst<P,F,S> ba) throws TimeoutException {
  SFT<P,F,S> aut=new SFT<P,F,S>();
  aut.initialState=initialState;
  for (  Integer state : finalStatesAndTails.keySet()) {
    Set<List<S>> tails=new HashSet<List<S>>();
    for (    List<S> tail : finalStatesAndTails.get(state)) {
      if (tail.size() != 0)       tails.add(tail);
    }
    aut.finalStatesAndTails.put(state,tails);
  }
  aut.states=new HashSet<Integer>();
  aut.states.add(initialState);
  aut.states.addAll(finalStatesAndTails.keySet());
  try {
    for (    SFTMove<P,F,S> t : transitions)     aut.addTransition(t,ba,false);
  }
 catch (  TimeoutException toe) {
    return null;
  }
  aut.isDeterministic=aut.checkDeterminism(ba);
  return aut;
}
Program: 42145
Project: 42145
Buggy source:
/** 
 * convert a sfa to a sft by adding empty set of output functions in every transition
 * @return corresponding sft
 */
private static <P,F,S>SFT<P,F,S> SFAtoSFT(SFA<P,S> sfa,BooleanAlgebraSubst<P,F,S> ba){
  Collection<SFTMove<P,F,S>> transitions=new ArrayList<SFTMove<P,F,S>>();
  for (  Integer state : sfa.getStates()) {
    for (    SFAInputMove<P,S> transition : sfa.getInputMovesFrom(state)) {
      List<F> outputFunctions=new LinkedList<F>();
      SFTInputMove<P,F,S> newTrans=new SFTInputMove<P,F,S>(transition.from,transition.to,transition.guard,outputFunctions);
      transitions.add(newTrans);
    }
    for (    SFAEpsilon<P,S> transition : sfa.getEpsilonFrom(state)) {
      List<S> outputs=new LinkedList<S>();
      SFTEpsilon<P,F,S> newTrans=new SFTEpsilon<P,F,S>(transition.from,transition.to,outputs);
      transitions.add(newTrans);
    }
  }
  Map<Integer,Set<List<S>>> finalStatesAndTails=new HashMap<Integer,Set<List<S>>>();
  for (  Integer finalState : sfa.getFinalStates())   finalStatesAndTails.put(finalState,new HashSet<List<S>>());
  return MkSFT(transitions,sfa.getInitialState(),finalStatesAndTails,ba);
}

Fixed version (ground truth):
/** 
 * convert a sfa to a sft by adding empty set of output functions in every transition
 * @return corresponding sft
 */
private static <P,F,S>SFT<P,F,S> SFAtoSFT(SFA<P,S> sfa,BooleanAlgebraSubst<P,F,S> ba) throws TimeoutException {
  Collection<SFTMove<P,F,S>> transitions=new ArrayList<SFTMove<P,F,S>>();
  for (  Integer state : sfa.getStates()) {
    for (    SFAInputMove<P,S> transition : sfa.getInputMovesFrom(state)) {
      List<F> outputFunctions=new LinkedList<F>();
      SFTInputMove<P,F,S> newTrans=new SFTInputMove<P,F,S>(transition.from,transition.to,transition.guard,outputFunctions);
      transitions.add(newTrans);
    }
    for (    SFAEpsilon<P,S> transition : sfa.getEpsilonFrom(state)) {
      List<S> outputs=new LinkedList<S>();
      SFTEpsilon<P,F,S> newTrans=new SFTEpsilon<P,F,S>(transition.from,transition.to,outputs);
      transitions.add(newTrans);
    }
  }
  Map<Integer,Set<List<S>>> finalStatesAndTails=new HashMap<Integer,Set<List<S>>>();
  for (  Integer finalState : sfa.getFinalStates())   finalStatesAndTails.put(finalState,new HashSet<List<S>>());
  return MkSFT(transitions,sfa.getInitialState(),finalStatesAndTails,ba);
}
Program: 42147
Project: 42147
Buggy source:
public static SFT<CharPred,CharFunc,Character> getTestSFTCounterexample(){
  List<SFTMove<CharPred,CharFunc,Character>> transitions=new LinkedList<>();
  Map<Integer,Set<List<Character>>> finalStates;
  transitions.add(new SFTInputMove<CharPred,CharFunc,Character>(0,0,new CharPred('b'),stringToCharFunc("String_Node_Str")));
  transitions.add(new SFTInputMove<CharPred,CharFunc,Character>(0,0,new CharPred('a'),stringToCharFunc("String_Node_Str")));
  HashSet<Integer> finalStatesSet=new HashSet<>();
  finalStatesSet.add(0);
  finalStates=setToFTMap(finalStatesSet);
  return SFT.MkSFT(transitions,0,finalStates,ba);
}

Fixed version (ground truth):
public static SFT<CharPred,CharFunc,Character> getTestSFTCounterexample() throws Exception {
  List<SFTMove<CharPred,CharFunc,Character>> transitions=new LinkedList<>();
  Map<Integer,Set<List<Character>>> finalStates;
  transitions.add(new SFTInputMove<CharPred,CharFunc,Character>(0,0,new CharPred('b'),stringToCharFunc("String_Node_Str")));
  transitions.add(new SFTInputMove<CharPred,CharFunc,Character>(0,0,new CharPred('a'),stringToCharFunc("String_Node_Str")));
  HashSet<Integer> finalStatesSet=new HashSet<>();
  finalStatesSet.add(0);
  finalStates=setToFTMap(finalStatesSet);
  return SFT.MkSFT(transitions,0,finalStates,ba);
}