docs: @Override
      public void visitInsn(int inst) {
          processPendingExceptionHandlerEntry(-1);
  
          // List of opcodes taken from visitInsn documentation
          if (waitingForSuper) {
              // Visit the instruction
              super.visitInsn(inst);
  
              switch (inst) {
                  case NOP:
                      break;
                  // One slot constants
                  case ACONST_NULL:
                  case ICONST_M1:
                  case ICONST_0:
                  case ICONST_1:
                  case ICONST_2:
                  case ICONST_3:
                  case ICONST_4:
                  case ICONST_5:
                  case FCONST_0:
                  case FCONST_1:
                  case FCONST_2:
                      push(OTHER, 1);
                      break;
                  // Two slot constants
                  case DCONST_0:
                  case DCONST_1:
                  case LCONST_0:
                  case LCONST_1:
                      push(OTHER, 2);
                      break;
                  // One slot array load
                  case IALOAD:
                  case FALOAD:
                  case AALOAD:
                  case BALOAD:
                  case CALOAD:
                  case SALOAD:
                      pop(1); // pop(2); push(OTHER, 1);
                      break;
                  // Two slot array load
                  case DALOAD:
                  case LALOAD:
                      // pop(2); push(OTHER, 2);
                      break;
                  // One slot array store
                  case IASTORE:
                  case FASTORE:
                  case AASTORE:
                  case BASTORE:
                  case CASTORE:
                  case SASTORE:
                      pop(3);
                      break;
                  // Two slot array store
                  case DASTORE:
                  case LASTORE:
                      pop(4);
                      break;
                  // Basic pop instructions
                  case POP:
                      pop(1);
                      break;
                  case POP2:
                      pop(2);
                      break;
                  // Stack manipulation instructions
                  case DUP: {
                      Object top = currentStack.get(currentStack.size() - 1);
                      push(top, 1);
                      break;
                  }
                  case DUP_X1: {
                      Object top = currentStack.get(currentStack.size() - 1);
                      int addPosition = currentStack.size() - 2;
                      currentStack.add(addPosition, top);
                      break;
                  }
                  case DUP_X2: {
                      Object top = currentStack.get(currentStack.size() - 1);
                      int addPosition = currentStack.size() - 3;
                      currentStack.add(addPosition, top);
                      break;
                  }
                  case DUP2: {
                      int position = currentStack.size() - 2;
                      currentStack.add(currentStack.get(position));
                      currentStack.add(currentStack.get(position + 1));
                      break;
                  }
                  case DUP2_X1: {
                      int addPosition = currentStack.size() - 3;
                      currentStack.add(addPosition, currentStack.get(currentStack.size() - 1));
                      currentStack.add(addPosition, currentStack.get(currentStack.size() - 2));
                      break;
                  }
                  case DUP2_X2: {
                      int addPosition = currentStack.size() - 4;
                      currentStack.add(addPosition, currentStack.get(currentStack.size() - 1));
                      currentStack.add(addPosition, currentStack.get(currentStack.size() - 2));
                      break;
                  }
                  case SWAP: {
                      Object o = currentStack.remove(currentStack.size() - 2);
                      currentStack.add(o);
                      break;
                  }
                  // One slot arithmetic and logical instructions
                  case IADD:
                  case FADD:
                  case ISUB:
                  case FSUB:
                  case IMUL:
                  case FMUL:
                  case IDIV:
                  case FDIV:
                  case IREM:
                  case FREM:
                  case INEG:
                  case FNEG:
                  case ISHL:
                  case ISHR:
                  case IUSHR:
                  case IAND:
                  case IOR:
                  case IXOR:
                      pop(1);
                      break;
                  // Two slot arithmetic and logical instructions
                  case DADD:
                  case LADD:
                  case DSUB:
                  case LSUB:
                  case DMUL:
                  case LMUL:
                  case DDIV:
                  case LDIV:
                  case DREM:
                  case LREM:
                  case DNEG:
                  case LNEG:
                  case LSHL:
                  case LSHR:
                  case LUSHR:
                  case LAND:
                  case LOR:
                  case LXOR:
                      pop(2);
                      break;
                  // One slot to two slot conversions
                  case I2D:
                  case I2L:
                  case F2D:
                  case F2L:
                      push(OTHER, 1);
                      break;
                  // One slot to one slot conversions
                  case F2I:
                  case I2B:
                  case I2C:
                  case I2F:
                  case I2S:
                      break;
                  // Two slot to one slot conversions
                  case D2F:
                  case D2I:
                  case L2I:
                  case L2F:
                      pop(1);
                      break;
                  // Two slot to two slot conversions
                  case L2D:
                  case D2L:
                      break;
                  // Two slot compare
                  case DCMPL:
                  case DCMPG:
                  case LCMP:
                      pop(3);
                      break;
                  // One slot compare
                  case FCMPL:
                  case FCMPG:
                      pop(1);
                      break;
                  // One slot return
                  case IRETURN:
                  case FRETURN:
                  case ARETURN:
                      pop(1);
                      break;
                  // Two slot return
                  case DRETURN:
                  case LRETURN:
                      pop(2);
                      break;
                  // Zero slot return
                  case RETURN:
                      break;
                  // Get array length
                  case ARRAYLENGTH:
                      break;
                  // Throw an exception
                  case ATHROW:
                      pop(1);
                      break;
                  // Enter or leave a monitor
                  case MONITORENTER:
                  case MONITOREXIT:
                      pop(1);
                      break;
                  default:
              }
          } else {
              // Handle return and throw instructions
              switch (inst) {
                  case RETURN:
                  case ARETURN:
                  case DRETURN:
                  case FRETURN:
                  case IRETURN:
                  case LRETURN:
                      if (onMethodReturn()) {
                          visitFrameAfterMethodReturnCallback();
                      }
                      break;
                  case ATHROW:
                      if (onThrowInstruction()) {
                          visitFrameAfterOnThrowCallback();
                      }
                      break;
              }
              super.visitInsn(inst);
          }
      }