docs: private static void formatBytesToSB (StringBuilder sb, byte[] data, int start, int countRequested, boolean displayCharRepresentations, int max) {
  
      if (max > MAX_TO_FORMAT) max = MAX_TO_FORMAT;                    // Ensure we can't be asked to format a completely bonkers amount of data
      int count = (countRequested <= max + 16) ? countRequested : max; // Determine how many bytes to format (giving 16 bytes leeway)
  
      if (data != null) {
        int len = data.length;
        sb.append("Array length = 0x"+Integer.toHexString(len)+" ("+len+"), displaying bytes from "+start+" for "+count);
        if (count < countRequested) {
          sb.append(" ("+countRequested+" bytes requested)");
        }
        sb.append(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(Integer.valueOf(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));
      }
  
      // If the number of bytes formatted was fewer than requested, say so.
      if (count < countRequested) {
        sb.append("Suppressed remaining " + (countRequested-count) + " bytes." + ls);
      }
    }