docs: protected long computeSVUID() throws IOException {
          ByteArrayOutputStream bos;
          DataOutputStream dos = null;
          long svuid = 0;
  
          try {
              bos = new ByteArrayOutputStream();
              dos = new DataOutputStream(bos);
  
              /*
               * 1. The class name written using UTF encoding.
               */
              dos.writeUTF(name.replace('/', '.'));
  
              /*
               * 2. The class modifiers written as a 32-bit integer.
               */
              dos.writeInt(access
                      & (Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL
                              | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT));
  
              /*
               * 3. The name of each interface sorted by name written using UTF
               * encoding.
               */
              Arrays.sort(interfaces);
              for (int i = 0; i < interfaces.length; i++) {
                  dos.writeUTF(interfaces[i].replace('/', '.'));
              }
  
              /*
               * 4. For each field of the class sorted by field name (except
               * private static and private transient fields):
               * 
               * 1. The name of the field in UTF encoding. 2. The modifiers of the
               * field written as a 32-bit integer. 3. The descriptor of the field
               * in UTF encoding
               * 
               * Note that field signatures are not dot separated. Method and
               * constructor signatures are dot separated. Go figure...
               */
              writeItems(svuidFields, dos, false);
  
              /*
               * 5. If a class initializer exists, write out the following: 1. The
               * name of the method, <clinit>, in UTF encoding. 2. The modifier of
               * the method, java.lang.reflect.Modifier.STATIC, written as a
               * 32-bit integer. 3. The descriptor of the method, ()V, in UTF
               * encoding.
               */
              if (hasStaticInitializer) {
                  dos.writeUTF("<clinit>");
                  dos.writeInt(Opcodes.ACC_STATIC);
                  dos.writeUTF("()V");
              } // if..
  
              /*
               * 6. For each non-private constructor sorted by method name and
               * signature: 1. The name of the method, <init>, in UTF encoding. 2.
               * The modifiers of the method written as a 32-bit integer. 3. The
               * descriptor of the method in UTF encoding.
               */
              writeItems(svuidConstructors, dos, true);
  
              /*
               * 7. For each non-private method sorted by method name and
               * signature: 1. The name of the method in UTF encoding. 2. The
               * modifiers of the method written as a 32-bit integer. 3. The
               * descriptor of the method in UTF encoding.
               */
              writeItems(svuidMethods, dos, true);
  
              dos.flush();
  
              /*
               * 8. The SHA-1 algorithm is executed on the stream of bytes
               * produced by DataOutputStream and produces five 32-bit values
               * sha[0..4].
               */
              byte[] hashBytes = computeSHAdigest(bos.toByteArray());
  
              /*
               * 9. The hash value is assembled from the first and second 32-bit
               * values of the SHA-1 message digest. If the result of the message
               * digest, the five 32-bit words H0 H1 H2 H3 H4, is in an array of
               * five int values named sha, the hash value would be computed as
               * follows:
               * 
               * long hash = ((sha[0] >>> 24) & 0xFF) | ((sha[0] >>> 16) & 0xFF)
               * << 8 | ((sha[0] >>> 8) & 0xFF) << 16 | ((sha[0] >>> 0) & 0xFF) <<
               * 24 | ((sha[1] >>> 24) & 0xFF) << 32 | ((sha[1] >>> 16) & 0xFF) <<
               * 40 | ((sha[1] >>> 8) & 0xFF) << 48 | ((sha[1] >>> 0) & 0xFF) <<
               * 56;
               */
              for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
                  svuid = (svuid << 8) | (hashBytes[i] & 0xFF);
              }
          } finally {
              // close the stream (if open)
              if (dos != null) {
                  dos.close();
              }
          }
  
          return svuid;
      }