if (match1 || match2 || match3)
if (match1 || match2 || match3)   { if (DEBUG) System.out.println("IL: " + match1 + " " + match2 + " " + match3);
	public void sawOpcode(int seen) {				if (seenReturn && seenTransferOfControl && seenStateChange) return;			if (DEBUG ) {		System.out.println(stack);			System.out.println(getPC() + " : " + OPCODE_NAMES[seen]);		}			if ((seen == INVOKEVIRTUAL || seen == INVOKEINTERFACE)			    && getNameConstantOperand().equals("add")			    && getSigConstantOperand().equals(				"(Ljava/lang/Object;)Z")			    && stack.getStackDepth() >= 2)  {				OpcodeStack.Item it0 = stack.getStackItem(0);				int r0 = it0.getRegisterNumber();				OpcodeStack.Item it1 = stack.getStackItem(1);				int r1 = it1.getRegisterNumber();				if (r0 == r1 && r0 > 0)				bugReporter.reportBug(new BugInstance(this, "IL_CONTAINER_ADDED_TO_ITSELF", NORMAL_PRIORITY)				        .addClassAndMethod(this)				        .addSourceLine(this)					);		}		if ((seen == INVOKEVIRTUAL || seen == INVOKESPECIAL || seen == INVOKEINTERFACE || seen == INVOKESTATIC) 			    && getNameConstantOperand().equals(getMethodName())			    && getSigConstantOperand().equals(getMethodSig())			    && ((seen == INVOKESTATIC) == getMethod().isStatic())			    && stack.getStackDepth() >= parameters)  {		if (DEBUG ) {		System.out.println("IL: Checking...");		System.out.println(getClassConstantOperand() + "." + getNameConstantOperand() + " : " + getSigConstantOperand());		System.out.println("vs. " + getClassName() + "." + getMethodName() + " : " + getMethodSig());		}		if ( getClassConstantOperand().equals(getClassName())				|| seen == INVOKEVIRTUAL || seen == INVOKEINTERFACE) {			// Invocation of same method			// Now need to see if parameters are the same			int firstParameter = 0;			if (getMethodName().equals("<init>")) firstParameter = 1;						// match1 should be true if it is any call to the exact same method			// and no state has been change. 			// if match1 is true, the method may not always perform			// a recursive infinite loop, but this particular method call is an infinite			// recursive loop						boolean match1 = !seenStateChange;			for(int i = firstParameter; match1 && i < parameters; i++) {				OpcodeStack.Item it = stack.getStackItem(parameters-1-i);				if (!it.isInitialParameter() || it.getRegisterNumber() != i)					match1 = false;				}						boolean sameMethod = 				seen == INVOKESTATIC				|| getNameConstantOperand().equals("<init>");			if (!sameMethod) {				// Have to check if first parmeter is the same				// know there must be a this argument				OpcodeStack.Item p = stack.getStackItem(parameters-1);				sameMethod = p.isInitialParameter()					&& p.getRegisterNumber() == 0;				}						// match2 and match3 are two different ways of seeing if the call site			// postdominates the method entry. 						// technically, we use (!seenTransferOfControl || !seenReturn && largestBranchTarget < getPC())			// as a check that the call site postdominates the method entry. If those are true,			// and sameMethod is true, we have a guaranteed IL.						boolean match2 = sameMethod && !seenTransferOfControl;			boolean match3 = sameMethod && !seenReturn && largestBranchTarget < getPC();			if (match1 || match2 || match3)  				bugReporter.reportBug(new BugInstance(this, "IL_INFINITE_RECURSIVE_LOOP", HIGH_PRIORITY)				        .addClassAndMethod(this)				        .addSourceLine(this)					);			}		}               switch(seen) {                       case ARETURN:                       case IRETURN:                       case LRETURN:                       case RETURN:                       case DRETURN:                       case FRETURN:				seenReturn = true;                               seenTransferOfControl = true;				break;			case PUTSTATIC:			case PUTFIELD:			case IASTORE:			case AASTORE:			case DASTORE:			case FASTORE:			case LASTORE:			case SASTORE:			case CASTORE:			case BASTORE:			case INVOKEVIRTUAL:			case INVOKESPECIAL:			case INVOKEINTERFACE:			case INVOKESTATIC:				seenStateChange = true;				break;                       }		stack.sawOpcode(this,seen);	}