docs: public static String formatBytes(byte[] data,
                                       int start,
                                       int count,
                                       boolean displayCharRepresentations) {
          StringBuffer sb = new StringBuffer();
  
          if (data != null) {
              int len = data.length;
              sb.append(ls
                        + "Length = 0x"
                        + Integer.toHexString(len)
                        + " ("
                        + len
                        + ") bytes start="
                        + start
                        + " count="
                        + count
                        + ls
                        + ls);
              if (displayCharRepresentations)
                  sb.append("        offset        : 0 1 2 3  4 5 6 7  8 9 A B  C D E F     0 2 4 6 8 A C E " + ls);
              else
                  sb.append("        offset        : 0 1 2 3  4 5 6 7  8 9 A B  C D E F" + ls);
  
              int t;
              boolean skip;
              int suppress = 0;
              int end = start + count;
              String c[] = new String[16]; // Current line bytes
              String p[] = new String[16]; // Previous line bytes
              String str[] = new String[16];// The string representation
  
              for (int j = 0; j < 16; j++) {
                  c[j] = null;
                  str[j] = null;
              }
  
              for (int i = 0; i < len; i = i + 16) {
                  skip = true;
  
                  for (int j = 0; j < 16; j++) {
                      t = i + j;
                      if ((t >= start) && (t < end) && (t < len)) {
                          c[j] = pad(Integer.toHexString(data[t]),
                                     2);
                          // Strip out some known 'bad-guys' (these are consistent across ASCII / EBCIDIC)
                          // and replace them with the dead character
                          if (c[j].equalsIgnoreCase("00") || // Null
                              c[j].equalsIgnoreCase("09") || // Tab
                              c[j].equalsIgnoreCase("0a") || // LF
                              c[j].equalsIgnoreCase("0b") || // VertTab
                              c[j].equalsIgnoreCase("0c") || // FF
                              c[j].equalsIgnoreCase("0d") || // CR
                              c[j].equalsIgnoreCase("07")) // Bell
                          {
                              str[j] = DEAD_CHAR;
                          } else {
                              str[j] = new String(data,
                                                  t,
                                                  1); // Conversion is done here using the default
                              // character set of the platform
                          }
                          skip = false;
                      } else {
                          c[j] = "  ";
                          str[j] = DEAD_CHAR;
                      }
                  }
  
                  if (skip) {
                      if (suppress > 0)
                          sb.append(dup(suppress));
                      suppress = 0;
                      c[0] = null; // Force a line difference
                  } else {
                      if (c[0].equals(p[0])
                          && c[1].equals(p[1])
                          && c[2].equals(p[2])
                          && c[3].equals(p[3])
                          && c[4].equals(p[4])
                          && c[5].equals(p[5])
                          && c[6].equals(p[6])
                          && c[7].equals(p[7])
                          && c[8].equals(p[8])
                          && c[9].equals(p[9])
                          && c[10].equals(p[10])
                          && c[11].equals(p[11])
                          && c[12].equals(p[12])
                          && c[13].equals(p[13])
                          && c[14].equals(p[14])
                          && c[15].equals(p[15])) {
                          suppress++;
                      } else {
                          if (suppress > 0)
                              sb.append(dup(suppress));
                          sb.append("0x" + pad(Integer.toHexString(i),
                                               8) + " (" + pad(new Integer(i).toString(),
                                                               8,
                                                               " ") + ") : ");
                          sb.append(c[0]
                                    + c[1]
                                    + c[2]
                                    + c[3]
                                    + " "
                                    + c[4]
                                    + c[5]
                                    + c[6]
                                    + c[7]
                                    + " "
                                    + c[8]
                                    + c[9]
                                    + c[10]
                                    + c[11]
                                    + " "
                                    + c[12]
                                    + c[13]
                                    + c[14]
                                    + c[15]);
                          if (displayCharRepresentations) {
                              sb.append("  | ");
                              sb.append(str[0]
                                        + str[1]
                                        + str[2]
                                        + str[3]
                                        + str[4]
                                        + str[5]
                                        + str[6]
                                        + str[7]
                                        + str[8]
                                        + str[9]
                                        + str[10]
                                        + str[11]
                                        + str[12]
                                        + str[13]
                                        + str[14]
                                        + str[15]);
                          }
                          sb.append(ls);
                          for (int j = 0; j < 16; j++)
                              p[j] = c[j];
                          suppress = 0;
                      }
                  }
              }
  
              if (suppress > 0)
                  sb.append(dup(suppress));
          }
  
          return sb.toString();
      }