docs: public void analyzeHash(boolean full)
                      throws IOException,
                      EOFException,
                      FileManagerException,
                      ClassNotFoundException,
                      HashtableOnDiskException {
          //
          // Warning: don't call this on a "live" htod or you'll get strange results.
          // This method is intended for quiesced analysis.
          //
          int totalsize = 0;
          long true_location;
  
          true_location = header.disklocation - SWORDSIZE;
          filemgr.seek(true_location);
          int header_size = filemgr.readInt();
  
          //println("--------------------------------------------------");
          //println("FileManager information:");
          //println("--------------------------------------------------");
          //filemgr.dump_memory();
          // filemgr.dump_disk_memory(filename);
          //filemgr.show_stats();
  
          println("\n\n");
          println("--------------------------------------------------");
          println("Header information:\n");
          println("--------------------------------------------------");
          println("Header location = " + true_location);
          println("Header size = " + header_size);
          println("Magic string = " + header.magic);
          println("currentTablePtr = " + header.currentTablePtr);
          println("num_objects = " + header.num_objects());
          println("loadFactor = " + header.loadFactor);
          println("rehashInProgress = " + header.rehashInProgress);
          println("currentTablePtr = " + header.currentTablePtr);
  
          if (header.tableLocation[0] == 0) {
              println("Hashtable[0] is empty\n");
          } else {
              println("Hashtable[0].tablesize = " + header.tablesize[0]);
              true_location = header.tableLocation[0] - SWORDSIZE;
              filemgr.seek(true_location);
              int physical_size = filemgr.readInt();
              println("Hashtable[0] physical location, size = " +
                      true_location + " " +
                      physical_size);
          }
  
          if (header.tableLocation[1] == 0) {
              println("Hashtable[1] is empty\n");
          } else {
              println("Hashtable[1].tablesize = " + header.tablesize[1]);
              true_location = header.tableLocation[1] - SWORDSIZE;
              filemgr.seek(true_location);
              int physical_size = filemgr.readInt();
              println("Hashtable[1] physical location, size = " +
                      true_location + " " +
                      physical_size);
          }
  
          println("--------------------------------------------------");
  
          if (true) {
              return;
          }
  
          int tableid = header.currentTableId();
          for (int i = 0; i < header.tablesize(); i++) {
  
              filemgr.seek(header.calcOffset(i, tableid));
              long location = filemgr.readLong();
              true_location = location - SWORDSIZE;
  
              //
              // First get true object length
              //
              HashtableEntry e = readEntry(location, 0, RETRIEVE_ALL, !CHECK_EXPIRED, tableid);
              int bucketSize = 0;
              Vector bucketList = new Vector(10, 10);
              println("Bucket " + i + " starts:");
              while (e != null) {
  
                  //
                  // First lets peek at actual storage allocation.  The int just before
                  // the entry is the buffered size, and the size of the actual object
                  // is the size of the object itself.
                  //
                  filemgr.seek(true_location);
                  int bufferedsize = filemgr.readInt();
                  filemgr.seek(e.location);
                  int objectsize = filemgr.readInt();
  
                  totalsize++;
                  bucketSize++;
                  // bucketList.add(new AnalyzeStruct(e.key, true_location, bufferedsize, objectsize));
  
                  println(".\t Entry = [loc(" +
                          true_location + ") bufsize(" +
                          bufferedsize + ") objsize(" +
                          objectsize + ") ] " +
                          e.key.toString());
                  if (full) {
                      println(" \t Data is class " + e.value.getClass().getName());
                      if (e.value.getClass().getName().equals("[B")) {
                          println(" \t Data = " + new String((byte[]) e.value));
                      } else {
                          println(" \t Data = " + e.value.toString());
                      }
                  }
                  println(" \t ----------------------------------------------");
  
                  true_location = e.next - SWORDSIZE;
                  e = readEntry(e.next, e.location, RETRIEVE_ALL, !CHECK_EXPIRED, tableid);
              }
  
              println("Bucket " + i + " ends, size= " + bucketSize + "\n");
  //             if ( bucketSize > 0 ) {
  //                 for (int j = 0; j < bucketSize; j++ ) {
  //                     AnalyzeStruct as = (AnalyzeStruct) bucketList.elementAt(j);
  //                     println(".\t [loc(" + 
  //                                        as.location + ") bufsize(" +
  //                                        as.buffersize + ") objsize(" +
  //                                        as.objectsize + ") ] " + 
  //                                        as.object.toString());
  //                 }
  //             }
  
          }
  
          println("Total objects in the hashtable = " + totalsize);
      }