if(searchResumeEntry != null && FSRepository.isValidRevision(searchResumeEntry.getRevision())){
if(searchResumeEntry != null && searchResumeEntry.getPath() != null && FSRepository.isValidRevision(searchResumeEntry.getRevision())){
    private FSNodeHistory historyPrev(File reposRootDir, /*FSNodeHistory hist,*/ boolean crossCopies, FSRevisionNodePool revNodesPool)throws SVNException{    	String path = historyEntry.getPath();//String path = hist.getHistoryEntry().getPath();    	SVNLocationEntry commitEntry;    	long revision = historyEntry.getRevision();//long revision = hist.getHistoryEntry().getRevision();    	boolean reported = isInteresting;//boolean reported = hist.getInterest();    	    	//If our last history report left us hints about where to pickup        //the chase, then our last report was on the destination of a        //copy.  If we are crossing copies, start from those locations,        //otherwise, we're all done here//    	if((hist.getSearchResumeEntry() != null) && (hist.getSearchResumeEntry().getPath() != null) && FSRepository.isValidRevision(hist.getSearchResumeEntry().getRevision()) ){    	if(searchResumeEntry != null && FSRepository.isValidRevision(searchResumeEntry.getRevision())){    		reported = false;    		if(crossCopies == false){    			return null;    		}    		path = searchResumeEntry.getPath();//path = hist.getSearchResumeEntry().getPath();    		revision = searchResumeEntry.getRevision();//revision = hist.getSearchResumeEntry().getRevision();    	}    	//Construct a ROOT for the current revision    	FSRevisionNode root = revNodesPool.getRootRevisionNode(revision, reposRootDir);/*FSReader.getRootRevNode(reposRootDir, revision);*/    	//Open path/revision and get all necessary info: node-id, ...    	FSParentPath parentPath = revNodesPool.getParentPath(FSRoot.createRevisionRoot(root.getId().getRevision(), root), path, true, reposRootDir);    	FSRevisionNode revNode = parentPath.getRevNode();    	commitEntry = new SVNLocationEntry(revNode.getId().getRevision(), revNode.getCreatedPath());     	//The Subversion filesystem is written in such a way that a given        //line of history may have at most one interesting history point        //per filesystem revision.  Either that node was edited (and        //possibly copied), or it was copied but not edited.  And a copy        //source cannot be from the same revision as its destination.  So,        //if our history revision matches its node's commit revision, we        //know that ...    	FSNodeHistory prevHist = null;    	if(revision == commitEntry.getRevision()){    		if(reported == false){    			prevHist = new FSNodeHistory(new SVNLocationEntry(commitEntry.getRevision(), commitEntry.getPath()),    					true, new SVNLocationEntry(FSConstants.SVN_INVALID_REVNUM, null));    			return prevHist;    		}    	    //... or we *have* reported on this revision, and must now            //progress toward this node's predecessor (unless there is            //no predecessor, in which case we're all done!)            FSID predId = revNode.getPredecessorId();            if(predId == null || predId.getRevision() < 0 ){                return prevHist;            }            //Replace NODE and friends with the information from its predecessor            revNode = FSReader.getRevNodeFromID(reposRootDir, predId);            commitEntry = new SVNLocationEntry(revNode.getId().getRevision(), revNode.getCreatedPath());    	}		//Find the youngest copyroot in the path of this node, including itself    	SVNLocationEntry copyrootEntry = FSNodeHistory.findYoungestCopyroot(reposRootDir, parentPath);		SVNLocationEntry srcEntry = new SVNLocationEntry(FSConstants.SVN_INVALID_REVNUM, null);		long dstRev = FSConstants.SVN_INVALID_REVNUM;		if(copyrootEntry.getRevision() > commitEntry.getRevision()){            FSRevisionNode copyrootRoot = revNodesPool.getRootRevisionNode(copyrootEntry.getRevision(), reposRootDir);//			FSRevisionNode copyrootRoot = FSReader.getRootRevNode(reposRootDir, copyrootEntry.getRevision());            revNode = revNodesPool.getRevisionNode(copyrootRoot, copyrootEntry.getPath(), reposRootDir);//			revNode = FSReader.getRevisionNode(reposRootDir, copyrootEntry.getPath(), copyrootRoot, 0);            String copyDst = revNode.getCreatedPath();          /* If our current path was the very destination of the copy,	         then our new current path will be the copy source.  If our	         current path was instead the *child* of the destination of	         the copy, then figure out its previous location by taking its	         path relative to the copy destination and appending that to	         the copy source.  Finally, if our current path doesn't meet	         one of these other criteria ... ### for now just fallback to	         the old copy hunt algorithm. 	       */						String reminder = new String();			if(path.equals(copyDst)){				reminder = "/";			}else{				reminder = SVNPathUtil.pathIsChild(copyDst, path);			}			if(reminder != null){	          /* If we get here, then our current path is the destination 	             of, or the child of the destination of, a copy.  Fill	             in the return values and get outta here.  	          */				String copySrc = revNode.getCopyFromPath();				srcEntry = new SVNLocationEntry(revNode.getCopyFromRevision(), SVNPathUtil.concatToAbs(copySrc, reminder));				dstRev = copyrootEntry.getRevision();			}		}		//If we calculated a copy source path and revision, we'll make a	    //'copy-style' history object.		if(srcEntry.getPath() != null && FSRepository.isValidRevision(srcEntry.getRevision())){		  /* It's possible for us to find a copy location that is the same	         as the history point we've just reported.  If that happens,	         we simply need to take another trip through this history	         search 	      */			boolean retry = false;			if(dstRev == revision && reported){				retry = true;			}			return new FSNodeHistory(new SVNLocationEntry(dstRev, path), retry ? false : true, new SVNLocationEntry(srcEntry.getRevision(), srcEntry.getPath()));		}        return new FSNodeHistory(commitEntry, true, new SVNLocationEntry(FSConstants.SVN_INVALID_REVNUM, null));	}