docs: private void append(final KeyValue column, 
                        final boolean is_count, 
                        final boolean strip_string) {
      // for now assume we properly allocated our qualifiers
      if (is_count) {
        int offset = strip_string ? 
            Internal.getOffsetFromQualifier(column.qualifier(), 
            RollupQuery.COUNT.length + 1) :
              Internal.getOffsetFromQualifier(column.qualifier(), 
                  1);
        if (last_count_offset > -1 && offset <= last_count_offset) {
          // only accept equivalent offsets. If somehow we get an earlier one, HBase is broke 
          if (offset == last_count_offset && tsdb.getConfig().fix_duplicates()) {
            if (column.timestamp() < last_count_ts) {
              if (LOG.isDebugEnabled()) {
                LOG.debug("Skipping older duplicate count value for " + column 
                + " of " + offset + " which is = the last offset " + last_count_offset
                + " for " + this);
              }
              return;
            } else { // if it's equal, just use the one we got first
              // roll back the indices
              indices[2] -= 2;
              indices[3] -= Internal.getValueLengthFromQualifier(
                  count_qualifiers, indices[2]);
              if (LOG.isDebugEnabled()) {
                LOG.debug("Replacing older duplicate count with " + column 
                + " of " + offset + " which is = the last offset " + last_count_offset
                + " for " + this);
              }
            }
          } else {
            throw new IllegalArgumentException("The count offset for " + column 
                + " of " + offset + " is <= the last offset " + last_count_offset
                + " for " + this);
          }
        }
        last_count_offset = offset;
        last_count_ts = column.timestamp();
        if (strip_string) {
          System.arraycopy(column.qualifier(), RollupQuery.COUNT.length + 1, 
              count_qualifiers, indices[2], 2);
        } else {
          System.arraycopy(column.qualifier(), 1, count_qualifiers, indices[2], 2);
        }
        indices[2] += 2;
        
        if (indices[3] + column.value().length > count_values.length) {
          byte[] buf = new byte[count_values.length * 2];
          System.arraycopy(count_values, 0, buf, 0, count_values.length);
          count_values = buf;
        }
        System.arraycopy(column.value(), 0, count_values, indices[3], 
            column.value().length);
        indices[3] += column.value().length;
      } else {
        int offset = strip_string ? 
            Internal.getOffsetFromQualifier(column.qualifier(), 
                rollup_query.getRollupAggPrefix().length)
            : Internal.getOffsetFromQualifier(column.qualifier(), 1);
        if (last_offset > -1 && offset <= last_offset) {
          // only accept equivalent offsets. If somehow we get an earlier one, HBase is broke
          if (offset == last_offset && tsdb.getConfig().fix_duplicates()) {
            if (column.timestamp() < last_value_ts) {
              if (LOG.isDebugEnabled()) {
                LOG.debug("Skipping older duplicate value for " + column 
                + " of " + offset + " which is = the last offset " + last_count_offset
                + " for " + this);
              }
              return;
            } else { // if it's equal, just use the one we got first
              // roll back the indices
              indices[0] -= 2;
              indices[1] -= Internal.getValueLengthFromQualifier(qualifiers, indices[0]);
              if (LOG.isDebugEnabled()) {
                LOG.debug("Replacing older duplicate value with " + column 
                + " of " + offset + " is = the last offset " + last_count_offset
                + " for " + this);
              }
            }
          } else {
            throw new IllegalDataException("The offset for " + column 
                + " of " + offset + " is <= the last offset " + last_offset
                + " for " + this);
          }
        }
        last_offset = offset;
        last_value_ts = column.timestamp();
        if (strip_string) {
          System.arraycopy(column.qualifier(), 
              rollup_query.getRollupAggPrefix().length, qualifiers, indices[0], 2);
        } else {
          System.arraycopy(column.qualifier(), 1, qualifiers, indices[0], 2);
        }
        indices[0] += 2;
        
        if (indices[1] + column.value().length > values.length) {
          byte[] buf = new byte[values.length * 2];
          System.arraycopy(values, 0, buf, 0, values.length);
          values = buf;
        }
        System.arraycopy(column.value(), 0, values, indices[1], 
            column.value().length);
        indices[1] += column.value().length;
      }
    }