docs: private void readConstantPoolEntries() throws IOException {
          // Only record class dependency info if inter-class dependencies are enabled
          List<Integer> classNameCpIdxs = null;
          List<Integer> typeSignatureIdxs = null;
          if (scanSpec.enableInterClassDependencies) {
              classNameCpIdxs = new ArrayList<Integer>();
              typeSignatureIdxs = new ArrayList<Integer>();
          }
  
          // Read size of constant pool
          cpCount = inputStreamOrByteBuffer.readUnsignedShort();
  
          // Allocate storage for constant pool
          entryOffset = new int[cpCount];
          entryTag = new int[cpCount];
          indirectStringRefs = new int[cpCount];
          Arrays.fill(indirectStringRefs, 0, cpCount, -1);
  
          // Read constant pool entries
          for (int i = 1, skipSlot = 0; i < cpCount; i++) {
              if (skipSlot == 1) {
                  // Skip a slot (keeps Scrutinizer happy -- it doesn't like i++ in case 6)
                  skipSlot = 0;
                  continue;
              }
              entryTag[i] = inputStreamOrByteBuffer.readUnsignedByte();
              entryOffset[i] = inputStreamOrByteBuffer.curr;
              switch (entryTag[i]) {
              case 0: // Impossible, probably buffer underflow
                  throw new ClassfileFormatException("Unknown constant pool tag 0 in classfile " + relativePath
                          + " (possible buffer underflow issue). Please report this at "
                          + "https://github.com/classgraph/classgraph/issues");
              case 1: // Modified UTF8
                  final int strLen = inputStreamOrByteBuffer.readUnsignedShort();
                  inputStreamOrByteBuffer.skip(strLen);
                  break;
              case 3: // int, short, char, byte, boolean are all represented by Constant_INTEGER
              case 4: // float
                  inputStreamOrByteBuffer.skip(4);
                  break;
              case 5: // long
              case 6: // double
                  inputStreamOrByteBuffer.skip(8);
                  skipSlot = 1; // double slot
                  break;
              case 7: // Class reference (format is e.g. "java/lang/String")
                  // Forward or backward indirect reference to a modified UTF8 entry
                  indirectStringRefs[i] = inputStreamOrByteBuffer.readUnsignedShort();
                  if (scanSpec.enableInterClassDependencies) {
                      // If this is a class ref, and inter-class dependencies are enabled, record the dependency
                      classNameCpIdxs.add(indirectStringRefs[i]);
                  }
                  break;
              case 8: // String
                  // Forward or backward indirect reference to a modified UTF8 entry
                  indirectStringRefs[i] = inputStreamOrByteBuffer.readUnsignedShort();
                  break;
              case 9: // field ref
                  // Refers to a class ref (case 7) and then a name and type (case 12)
                  inputStreamOrByteBuffer.skip(4);
                  break;
              case 10: // method ref
                  // Refers to a class ref (case 7) and then a name and type (case 12)
                  inputStreamOrByteBuffer.skip(4);
                  break;
              case 11: // interface method ref
                  // Refers to a class ref (case 7) and then a name and type (case 12)
                  inputStreamOrByteBuffer.skip(4);
                  break;
              case 12: // name and type
                  final int nameRef = inputStreamOrByteBuffer.readUnsignedShort();
                  final int typeRef = inputStreamOrByteBuffer.readUnsignedShort();
                  if (scanSpec.enableInterClassDependencies) {
                      typeSignatureIdxs.add(typeRef);
                  }
                  indirectStringRefs[i] = (nameRef << 16) | typeRef;
                  break;
              case 15: // method handle
                  inputStreamOrByteBuffer.skip(3);
                  break;
              case 16: // method type
                  inputStreamOrByteBuffer.skip(2);
                  break;
              case 18: // invoke dynamic
                  inputStreamOrByteBuffer.skip(4);
                  break;
              case 19: // module (for module-info.class in JDK9+)
                  // see https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.4
                  indirectStringRefs[i] = inputStreamOrByteBuffer.readUnsignedShort();
                  break;
              case 20: // package (for module-info.class in JDK9+)
                  // see https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.4
                  inputStreamOrByteBuffer.skip(2);
                  break;
              default:
                  throw new ClassfileFormatException("Unknown constant pool tag " + entryTag[i]
                          + " (element size unknown, cannot continue reading class). Please report this at "
                          + "https://github.com/classgraph/classgraph/issues");
              }
          }
  
          // Find classes referenced in the constant pool (note that there are some class refs that will not be
          // found this way, e.g. enum classes and class refs in annotation parameter values, since they are
          // referenced as strings (tag 1) rather than classes (tag 7) or type signatures (part of tag 12)).
          if (scanSpec.enableInterClassDependencies) {
              refdClassNames = new HashSet<>();
              // Get class names from direct class references in constant pool
              for (final int cpIdx : classNameCpIdxs) {
                  final String refdClassName = getConstantPoolString(cpIdx, /* replaceSlashWithDot = */ true,
                          /* stripLSemicolon = */ false);
                  if (refdClassName != null) {
                      if (refdClassName.startsWith("[")) {
                          // Parse array type signature, e.g. "[Ljava.lang.String;" -- uses '.' rather than '/'
                          try {
                              final TypeSignature typeSig = TypeSignature.parse(refdClassName.replace('.', '/'),
                                      /* definingClass = */ null);
                              typeSig.findReferencedClassNames(refdClassNames);
                          } catch (final ParseException e) {
                              // Should not happen
                              throw new ClassfileFormatException("Could not parse class name: " + refdClassName, e);
                          }
                      } else {
                          refdClassNames.add(refdClassName);
                      }
                  }
              }
              // Get class names from type signatures in "name and type" entries in constant pool
              for (final int cpIdx : typeSignatureIdxs) {
                  final String typeSigStr = getConstantPoolString(cpIdx);
                  if (typeSigStr != null) {
                      try {
                          if (typeSigStr.indexOf('(') >= 0 || "<init>".equals(typeSigStr)) {
                              // Parse the type signature
                              final MethodTypeSignature typeSig = MethodTypeSignature.parse(typeSigStr,
                                      /* definingClassName = */ null);
                              // Extract class names from type signature
                              typeSig.findReferencedClassNames(refdClassNames);
                          } else {
                              // Parse the type signature
                              final TypeSignature typeSig = TypeSignature.parse(typeSigStr,
                                      /* definingClassName = */ null);
                              // Extract class names from type signature
                              typeSig.findReferencedClassNames(refdClassNames);
                          }
                      } catch (final ParseException e) {
                          throw new ClassfileFormatException("Could not parse type signature: " + typeSigStr, e);
                      }
                  }
              }
          }
      }