InstructionHandle handle = redundantBranch.handle;
	private void analyzeMethod(ClassContext classContext, Method method)	        throws CFGBuilderException, DataflowAnalysisException {		if (DEBUG) System.out.println("Clearing redundant branch information");		redundantBranchList.clear();		definitelySameBranchSet.clear();		definitelyDifferentBranchSet.clear();		undeterminedBranchSet.clear();		if (DEBUG)			System.out.println(SignatureConverter.convertMethodSignature(classContext.getMethodGen(method)));		// Get the IsNullValueAnalysis for the method from the ClassContext		IsNullValueDataflow invDataflow = classContext.getIsNullValueDataflow(method);		// Look for null check blocks where the reference being checked		// is definitely null, or null on some path		Iterator<BasicBlock> bbIter = invDataflow.getCFG().blockIterator();		while (bbIter.hasNext()) {			BasicBlock basicBlock = bbIter.next();			if (basicBlock.isNullCheck()) {				analyzeNullCheck(classContext, method, invDataflow, basicBlock);			} else if (!basicBlock.isEmpty()) {				// Look for all reference comparisons where				//    - both values compared are definitely null, or				//    - one value is definitely null and one is definitely not null				// These cases are not null dereferences,				// but they are quite likely to indicate an error, so while we've got				// information about null values, we may as well report them.				InstructionHandle lastHandle = basicBlock.getLastInstruction();				Instruction last = lastHandle.getInstruction();				switch (last.getOpcode()) {				case Constants.IF_ACMPEQ:				case Constants.IF_ACMPNE:					analyzeRefComparisonBranch(method, invDataflow, basicBlock, lastHandle);					break;				case Constants.IFNULL:				case Constants.IFNONNULL:					analyzeIfNullBranch(method, invDataflow, basicBlock, lastHandle);					break;				}			}		}		Iterator<RedundantBranch> i = redundantBranchList.iterator();		while (i.hasNext()) {			RedundantBranch redundantBranch = i.next();			if (DEBUG) System.out.println("Redundant branch: " + redundantBranch);			InstructionHandle handle = redundantBranch.handle;			int lineNumber = redundantBranch.lineNumber;			// The source to bytecode compiler may sometimes duplicate blocks of			// code along different control paths.  So, to report the bug,			// we check to ensure that the branch is REALLY determined each			// place it is duplicated, and that it is determined in the same way.			if (!undeterminedBranchSet.get(lineNumber) &&			        !(definitelySameBranchSet.get(lineNumber) && definitelyDifferentBranchSet.get(lineNumber))) {				reportRedundantNullCheck(classContext, method, handle, redundantBranch);			}		}	}