Program: 55901
Project: 55901
Buggy source:
@Override public final Path findPath(IPathCalculatable requester,final short sx,final short sy,final short tx,final short ty){
  final boolean blockedAtStart;
  if (!isInBounds(sx,sy)) {
    throw new InvalidStartPositionException("String_Node_Str",sx,sy);
  }
 else   if (!isInBounds(tx,ty) || isBlocked(requester,tx,ty) || map.getBlockedPartition(sx,sy) != map.getBlockedPartition(tx,ty)) {
    return null;
  }
 else   if (sx == tx && sy == ty) {
    return null;
  }
 else   if (isBlocked(requester,sx,sy)) {
    blockedAtStart=true;
  }
 else {
    blockedAtStart=false;
  }
  final int targetFlatIdx=getFlatIdx(tx,ty);
  closedBitSet.clear();
  openBitSet.clear();
  open.clear();
  boolean found=false;
  initStartNode(sx,sy,tx,ty);
  while (!open.isEmpty()) {
    int currFlatIdx=open.deleteMin();
    final int x=getX(currFlatIdx);
    final int y=getY(currFlatIdx);
    setClosed(x,y);
    if (targetFlatIdx == currFlatIdx) {
      found=true;
      break;
    }
    final float currPositionCosts=costs[currFlatIdx];
    for (int i=0; i < EDirection.NUMBER_OF_DIRECTIONS; i++) {
      final int neighborX=x + xDeltaArray[i];
      final int neighborY=y + yDeltaArray[i];
      if (isValidPosition(requester,neighborX,neighborY,blockedAtStart)) {
        final int flatNeighborIdx=getFlatIdx(neighborX,neighborY);
        if (!closedBitSet.get(flatNeighborIdx)) {
          final float newCosts=currPositionCosts + map.getCost(x,y,neighborX,neighborY);
          if (openBitSet.get(flatNeighborIdx)) {
            final float oldCosts=costs[flatNeighborIdx];
            if (oldCosts > newCosts) {
              costs[flatNeighborIdx]=newCosts;
              depthParentHeap[getDepthIdx(flatNeighborIdx)]=depthParentHeap[getDepthIdx(currFlatIdx)] + 1;
              depthParentHeap[getParentIdx(flatNeighborIdx)]=currFlatIdx;
              int heuristicCosts=getHeuristicCost(neighborX,neighborY,tx,ty);
              open.increasedPriority(flatNeighborIdx,oldCosts + heuristicCosts,newCosts + heuristicCosts);
            }
          }
 else {
            costs[flatNeighborIdx]=newCosts;
            depthParentHeap[getDepthIdx(flatNeighborIdx)]=depthParentHeap[getDepthIdx(currFlatIdx)] + 1;
            depthParentHeap[getParentIdx(flatNeighborIdx)]=currFlatIdx;
            openBitSet.set(flatNeighborIdx);
            open.insert(flatNeighborIdx,newCosts + getHeuristicCost(neighborX,neighborY,tx,ty));
            map.markAsOpen(neighborX,neighborY);
          }
        }
      }
    }
  }
  if (found) {
    int pathlength=depthParentHeap[getDepthIdx(getFlatIdx(tx,ty))];
    Path path=new Path(pathlength);
    int idx=pathlength;
    int parentFlatIdx=targetFlatIdx;
    while (idx > 0) {
      idx--;
      path.insertAt(idx,(short)getX(parentFlatIdx),(short)getY(parentFlatIdx));
      parentFlatIdx=depthParentHeap[getParentIdx(parentFlatIdx)];
    }
    return path;
  }
  return null;
}

Fixed version (ground truth):
@Override public final Path findPath(IPathCalculatable requester,final short sx,final short sy,final short tx,final short ty){
  final short blockedAtStartPartition;
  if (!isInBounds(sx,sy)) {
    throw new InvalidStartPositionException("String_Node_Str",sx,sy);
  }
 else   if (!isInBounds(tx,ty) || isBlocked(requester,tx,ty) || map.getBlockedPartition(sx,sy) != map.getBlockedPartition(tx,ty)) {
    return null;
  }
 else   if (sx == tx && sy == ty) {
    return null;
  }
 else   if (isBlocked(requester,sx,sy)) {
    blockedAtStartPartition=map.getBlockedPartition(sx,sy);
  }
 else {
    blockedAtStartPartition=-1;
  }
  final int targetFlatIdx=getFlatIdx(tx,ty);
  closedBitSet.clear();
  openBitSet.clear();
  open.clear();
  boolean found=false;
  initStartNode(sx,sy,tx,ty);
  while (!open.isEmpty()) {
    int currFlatIdx=open.deleteMin();
    final int x=getX(currFlatIdx);
    final int y=getY(currFlatIdx);
    setClosed(x,y);
    if (targetFlatIdx == currFlatIdx) {
      found=true;
      break;
    }
    final float currPositionCosts=costs[currFlatIdx];
    for (int i=0; i < EDirection.NUMBER_OF_DIRECTIONS; i++) {
      final int neighborX=x + xDeltaArray[i];
      final int neighborY=y + yDeltaArray[i];
      if (isValidPosition(requester,neighborX,neighborY,blockedAtStartPartition)) {
        final int flatNeighborIdx=getFlatIdx(neighborX,neighborY);
        if (!closedBitSet.get(flatNeighborIdx)) {
          final float newCosts=currPositionCosts + map.getCost(x,y,neighborX,neighborY);
          if (openBitSet.get(flatNeighborIdx)) {
            final float oldCosts=costs[flatNeighborIdx];
            if (oldCosts > newCosts) {
              costs[flatNeighborIdx]=newCosts;
              depthParentHeap[getDepthIdx(flatNeighborIdx)]=depthParentHeap[getDepthIdx(currFlatIdx)] + 1;
              depthParentHeap[getParentIdx(flatNeighborIdx)]=currFlatIdx;
              int heuristicCosts=getHeuristicCost(neighborX,neighborY,tx,ty);
              open.increasedPriority(flatNeighborIdx,oldCosts + heuristicCosts,newCosts + heuristicCosts);
            }
          }
 else {
            costs[flatNeighborIdx]=newCosts;
            depthParentHeap[getDepthIdx(flatNeighborIdx)]=depthParentHeap[getDepthIdx(currFlatIdx)] + 1;
            depthParentHeap[getParentIdx(flatNeighborIdx)]=currFlatIdx;
            openBitSet.set(flatNeighborIdx);
            open.insert(flatNeighborIdx,newCosts + getHeuristicCost(neighborX,neighborY,tx,ty));
            map.markAsOpen(neighborX,neighborY);
          }
        }
      }
    }
  }
  if (found) {
    int pathlength=depthParentHeap[getDepthIdx(getFlatIdx(tx,ty))];
    Path path=new Path(pathlength);
    int idx=pathlength;
    int parentFlatIdx=targetFlatIdx;
    while (idx > 0) {
      idx--;
      path.insertAt(idx,(short)getX(parentFlatIdx),(short)getY(parentFlatIdx));
      parentFlatIdx=depthParentHeap[getParentIdx(parentFlatIdx)];
    }
    return path;
  }
  return null;
}