docs: @Override
      public void sawOpcode(int seen) {
          if (seenReturn && seenTransferOfControl && seenStateChange) {
              return;
          }
  
          if (DEBUG) {
              System.out.println(stack);
              System.out.println(getPC() + " : " + Const.getOpcodeName(seen));
          }
  
          if ((seen == Const.INVOKEVIRTUAL || seen == Const.INVOKEINTERFACE) && "add".equals(getNameConstantOperand())
                  && "(Ljava/lang/Object;)Z".equals(getSigConstantOperand()) && 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 == Const.INVOKEVIRTUAL || seen == Const.INVOKESPECIAL || seen == Const.INVOKEINTERFACE || seen == Const.INVOKESTATIC)
                  && getNameConstantOperand().equals(getMethodName())
                  && getSigConstantOperand().equals(getMethodSig())
                  && (seen == Const.INVOKESTATIC) == getMethod().isStatic()
                  && (seen == Const.INVOKESPECIAL) == (getMethod().isPrivate() && !getMethod().isStatic() || Const.CONSTRUCTOR_NAME.equals(getMethodName()))) {
              Type arguments[] = getMethod().getArgumentTypes();
              // stack.getStackDepth() >= parameters
              int parameters = arguments.length;
              if (!getMethod().isStatic()) {
                  parameters++;
              }
              XMethod xMethod = XFactory.createReferencedXMethod(this);
              if (DEBUG) {
                  System.out.println("IL: Checking...");
                  System.out.println(xMethod);
                  System.out.println("vs. " + getClassName() + "." + getMethodName() + " : " + getMethodSig());
  
              }
              if (xMethod.getClassName().replace('.', '/').equals(getClassName()) || seen == Const.INVOKEINTERFACE) {
                  // Invocation of same method
                  // Now need to see if parameters are the same
                  int firstParameter = 0;
                  if (Const.CONSTRUCTOR_NAME.equals(getMethodName())) {
                      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 == Const.INVOKESTATIC || Const.CONSTRUCTOR_NAME.equals(getNameConstantOperand());
                  if (!sameMethod) {
                      // Have to check if first parmeter is the same
                      // know there must be a this argument
                      if (DEBUG) {
                          System.out.println("Stack is " + stack);
                      }
                      OpcodeStack.Item p = stack.getStackItem(parameters - 1);
                      if (DEBUG) {
                          System.out.println("parameters = " + parameters + ", Item is " + p);
                      }
                      String sig = p.getSignature();
                      sameMethod = p.isInitialParameter() && p.getRegisterNumber() == 0 && sig.equals("L" + getClassName() + ";");
  
                  }
  
                  // 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) {
                      if (DEBUG) {
                          System.out.println("IL: " + sameMethod + " " + match1 + " " + match2 + " " + match3);
                      }
                      //                    int priority = HIGH_PRIORITY;
                      //                    if (!match1 && !match2 && seenThrow)
                      //                        priority = NORMAL_PRIORITY;
                      //                    if (seen == Const.INVOKEINTERFACE)
                      //                        priority = NORMAL_PRIORITY;
                      bugReporter.reportBug(new BugInstance(this, "IL_INFINITE_RECURSIVE_LOOP", HIGH_PRIORITY).addClassAndMethod(
                              this).addSourceLine(this));
                  }
              }
          }
  
          switch (seen) {
          case Const.ARETURN:
          case Const.IRETURN:
          case Const.LRETURN:
          case Const.RETURN:
          case Const.DRETURN:
          case Const.FRETURN:
              seenReturn = true;
              seenTransferOfControl = true;
              break;
          case Const.ATHROW:
              //            seenThrow = true;
              seenTransferOfControl = true;
              break;
          case Const.PUTSTATIC:
          case Const.PUTFIELD:
          case Const.IASTORE:
          case Const.AASTORE:
          case Const.DASTORE:
          case Const.FASTORE:
          case Const.LASTORE:
          case Const.SASTORE:
          case Const.CASTORE:
          case Const.BASTORE:
              seenStateChange = true;
              break;
          case Const.INVOKEVIRTUAL:
          case Const.INVOKESPECIAL:
          case Const.INVOKEINTERFACE:
          case Const.INVOKESTATIC:
              if ("print".equals(getNameConstantOperand()) || "println".equals(getNameConstantOperand())
                      || "log".equals(getNameConstantOperand()) || "toString".equals(getNameConstantOperand())) {
                  break;
              }
              seenStateChange = true;
              break;
          default:
              break;
          }
      }