SVNLocationEntry sEntry = FSReader.copiedFrom(myReposRootDir, croot, cpath, myRevNodesPool);
SVNLocationEntry sEntry = FSReader.copiedFrom(myReposRootDir, FSRoot.createRevisionRoot(croot.getId().getRevision(), croot), cpath, myRevNodesPool);
    public int getLocations(String path, long pegRevision, long[] revisions, ISVNLocationEntryHandler handler) throws SVNException {        assertValidRevision(pegRevision);        for (int i = 0; i < revisions.length; i++) {            assertValidRevision(revisions[i]);        }        try{    		openRepository();            path = getRepositoryPath(path);            ArrayList locationEntries = new ArrayList(0);                        long[] locationRevs = new long[revisions.length];            long revision;            FSRevisionNode root = null;            //Sort revisions from greatest downward            Arrays.sort(revisions);            for(int i = 0; i < revisions.length; ++i){            	locationRevs[i] = revisions[revisions.length - (i + 1)];            }                                   	//Ignore revisions R that are younger than the pegRevisions where            //path@pegRevision is not an ancestor of path@R.            int count = 0;            boolean isAncestor = false;            for(count = 0; count < locationRevs.length && locationRevs[count] > pegRevision; ++count){                                isAncestor = FSNodeHistory.checkAncestryOfPegPath(myReposRootDir, path, pegRevision, locationRevs[count], myRevNodesPool);            	if(isAncestor){            		break;            	}            }            if(count >= locationRevs.length){            	return 0;            }            revision = isAncestor ? locationRevs[count] : pegRevision;                                        while(count < revisions.length){            	//Find the target of the innermost copy relevant to path@revision.           	    //The copy may be of path itself, or of a parent directory.            	           		root = FSReader.getRootRevNode(myReposRootDir, revision);           		FSClosestCopy tempClCopy = closestCopy(FSRoot.createRevisionRoot(revision, root), path);           		if(tempClCopy == null){           			break;           		}                FSRevisionNode croot = tempClCopy.getRevisionNode();           		if(croot == null){           			break;           		}           		String cpath = tempClCopy.getPath();           		//Assign the current path to all younger revisions until we reach           		//the copy target rev                long crev = croot.getId().isTxn() ? FSConstants.SVN_INVALID_REVNUM : croot.getId().getRevision();            	while((count < revisions.length) && (locationRevs[count] >= crev)){            		locationEntries.add(new SVNLocationEntry(locationRevs[count], path));            		++count;            	}            	// Follow the copy to its source.  Ignore all revs between the                // copy target rev and the copy source rev (non-inclusive).            	SVNLocationEntry sEntry = FSReader.copiedFrom(myReposRootDir, croot, cpath, myRevNodesPool);                /*!!here is inconsitance with code of svn: they write locationRevs[count] > sEntry.getRevision()*/           		while((count < revisions.length) && locationRevs[count] > sEntry.getRevision()){           			++count;           		}                /* Ultimately, it's not the path of the closest copy's source                 * that we care about -- it's our own path's location in the                 * copy source revision.  So we'll tack the relative path that                 * expresses the difference between the copy destination and our                 * path in the copy revision onto the copy source path to                 * determine this information.                   * In other words, if our path is "/branches/my-branch/foo/bar",                 * and we know that the closest relevant copy was a copy of                 * "/trunk" to "/branches/my-branch", then that relative path                 * under the copy destination is "/foo/bar".  Tacking that onto                 * the copy source path tells us that our path was located at                 * "/trunk/foo/bar" before the copy.                 */            	String remainder = path.equals(cpath) ? "" : SVNPathUtil.pathIsChild(cpath, path);            	path = SVNPathUtil.concatToAbs(sEntry.getPath(), remainder);    		            	revision = sEntry.getRevision();            }            /* There are no copies relevant to path@revision.  So any remaining             * revisions either predate the creation of path@revision or have             * the node existing at the same path.  We will look up path@lrev             * for each remaining location-revision and make sure it is related             * to path@revision.              */    	       		root = myRevNodesPool.getRootRevisionNode(revision, myReposRootDir);//FSReader.getRootRevNode(myReposRootDir, revision);       		FSRevisionNode curNode = myRevNodesPool.getRevisionNode(root, path, myReposRootDir);//FSReader.getRevisionNode(myReposRootDir, path, root, 0);       		while(count < revisions.length){            	root = myRevNodesPool.getRootRevisionNode(locationRevs[count], myReposRootDir);//FSReader.getRootRevNode(myReposRootDir, locationRevs[count]);                SVNNodeKind kind = checkNodeKind(path, FSRoot.createRevisionRoot(locationRevs[count], root));            	if(kind == SVNNodeKind.NONE){            		break;            	}            	FSRevisionNode currentNode = myRevNodesPool.getRevisionNode(root, path, myReposRootDir);//FSReader.getRevisionNode(myReposRootDir, path, root, 0);            	            	if(!FSID.checkIdsRelated(curNode.getId(), currentNode.getId())){            		break;            	}                /* The node exists at the same path; record that and advance. */                locationEntries.add(new SVNLocationEntry(locationRevs[count], path));            	++count;            }       		            for(count = 0; count < locationEntries.size(); count++){                /* make sure we have a handler */                if(handler != null){                    handler.handleLocationEntry((SVNLocationEntry)locationEntries.get(count));                }            }            return count;    	}finally{    		closeRepository();    	}            }