*/
}
	public int compare(BugInstance lhs, BugInstance rhs) {		// Attributes of BugInstance.		// Compare abbreviation 		// Compare class and method annotations (ignoring line numbers).		// Compare field annotations.		int cmp;				BugPattern lhsPattern = lhs.getBugPattern();		BugPattern rhsPattern = rhs.getBugPattern();				if (lhsPattern == null || rhsPattern == null) {			// One of the patterns is missing.			// However, we can still accurately match by abbrev (usually) by comparing			// the part of the type before the first '_' character.			// This is almost always equivalent to the abbrev.						String lhsCode = getCode(lhs.getType());			String rhsCode = getCode(rhs.getType());						if ((cmp = lhsCode.compareTo(rhsCode)) != 0) {				return cmp;			}		} else {			// Compare by abbrev instead of type. The specific bug type can change			// (e.g., "definitely null" to "null on simple path").  Also, we often			// change bug pattern types from one version of FindBugs to the next.			//			// Source line and field name are still matched precisely, so this shouldn't			// cause loss of precision.			if ((cmp = lhsPattern.getAbbrev().compareTo(rhsPattern.getAbbrev())) != 0)				return cmp;		}		/*		// Don't compare priority.		// This is something that can reasonably change		// from one release of FindBugs to anther.		cmp = lhs.getPriority() - rhs.getPriority();		if (cmp != 0) return cmp;*/		Iterator<BugAnnotation> lhsIter = new FilteringAnnotationIterator(lhs.annotationIterator());		Iterator<BugAnnotation> rhsIter = new FilteringAnnotationIterator(rhs.annotationIterator());		while (lhsIter.hasNext() && rhsIter.hasNext()) {			BugAnnotation lhsAnnotation = lhsIter.next();			BugAnnotation rhsAnnotation = rhsIter.next();			// Different annotation types obviously cannot be equal,			// so just compare by class name.			if (lhsAnnotation.getClass() != rhsAnnotation.getClass())				return lhsAnnotation.getClass().getName().compareTo(rhsAnnotation.getClass().getName());			if (lhsAnnotation.getClass() == ClassAnnotation.class) {				// ClassAnnotations should have their class names rewritten to				// handle moved and renamed classes.								String lhsClassName = classNameRewriter.rewriteClassName(						((ClassAnnotation)lhsAnnotation).getClassName());				String rhsClassName = classNameRewriter.rewriteClassName(						((ClassAnnotation)rhsAnnotation).getClassName());								return lhsClassName.compareTo(rhsClassName);							} else if(lhsAnnotation.getClass() == MethodAnnotation.class ) {				// Rewrite class names in MethodAnnotations				MethodAnnotation lhsMethod = ClassNameRewriterUtil.convertMethodAnnotation(						classNameRewriter, (MethodAnnotation) lhsAnnotation);				MethodAnnotation rhsMethod = ClassNameRewriterUtil.convertMethodAnnotation(						classNameRewriter, (MethodAnnotation) rhsAnnotation);								cmp = lhsMethod.compareTo(rhsMethod);				if (cmp != 0)					return cmp;							} else if(lhsAnnotation.getClass() == FieldAnnotation.class) {				// Rewrite class names in FieldAnnotations				FieldAnnotation lhsField = ClassNameRewriterUtil.convertFieldAnnotation(						classNameRewriter, (FieldAnnotation) lhsAnnotation);				FieldAnnotation rhsField = ClassNameRewriterUtil.convertFieldAnnotation(						classNameRewriter, (FieldAnnotation) rhsAnnotation);								cmp = lhsField.compareTo(rhsField);				if (cmp != 0)					return cmp;			} else if (lhsAnnotation.getClass() == SourceLineAnnotation.class) {				// We assume that source lines may change, but source files				// and bytecode offsets will not.				SourceLineAnnotation lhsSource = (SourceLineAnnotation) lhsAnnotation;				SourceLineAnnotation rhsSource = (SourceLineAnnotation) rhsAnnotation;				cmp = lhsSource.getSourceFile().compareTo(rhsSource.getSourceFile());				if (cmp != 0) return cmp;				cmp = lhsSource.getStartBytecode() - rhsSource.getStartBytecode();				if (cmp != 0) return cmp;				cmp = lhsSource.getEndBytecode() - rhsSource.getEndBytecode();				if (cmp != 0) return cmp;			} else if (isBoring(lhsAnnotation)) {				throw new IllegalStateException("Impossible");			} else				throw new IllegalStateException("Unknown annotation type: " + lhsAnnotation.getClass().getName());		}		if (rhsIter.hasNext())			return -1;		else if (lhsIter.hasNext())			return 1;		else			return 0;	}