merged.Totals[i] = AccElem{
			Total: l.Totals[i].Total + o.Totals[i].Total,
			N:     l.Totals[i].N + o.Totals[i].N,
			Size:  l.Totals[i].Size + o.Totals[i].Size,
		}
	}
	return merged
}

// Add  a new duration data
func (l *ReplicationLastHour) addsize(sz int64) {
	minutes := time.Now().Unix() / 60
	l.forwardTo(minutes)
	winIdx := minutes % 60

								return
							}
						case "Size":
							z[za0001].Totals[za0002].Size, err = dc.ReadInt64()
							if err != nil {
								err = msgp.WrapError(err, za0001, "Totals", za0002, "Size")
								return
							}
						case "N":
							z[za0001].Totals[za0002].N, err = dc.ReadInt64()
							if err != nil {
								err = msgp.WrapError(err, za0001, "Totals", za0002, "N")

				if v.N > 0 {
					di.Metrics.LastMinute[k] = v.asTimedAction()
				}
			}
			maps.Copy(di.Metrics.APICalls, info.Metrics.APICalls)
			if info.Total > 0 {
				di.Utilization = float64(info.Used / info.Total * 100)
			}
			disksInfo[index] = di
			return nil
		}, index)
	}

	g.Wait()
	return disksInfo
}

// Get an aggregated storage info across all disks.

| `minio_s3_requests_inflight_total`            | Total number of S3 requests currently in flight.         |
| `minio_s3_requests_rejected_auth_total`       | Total number S3 requests rejected for auth failure.      |
| `minio_s3_requests_rejected_header_total`     | Total number S3 requests rejected for invalid header.    |

			f.newCache.replaceHashed(thisHash, folder.parent, *flat)
			total := map[string]string{
				"objects": strconv.FormatUint(flat.Objects, 10),
				"size":    strconv.FormatInt(flat.Size, 10),
			}
			if flat.Versions > 0 {
				total["versions"] = strconv.FormatUint(flat.Versions, 10)
			}
			stop(total)
		}
	}
	// Compact if too many children...
	if !into.Compacted {

			a.Size = atomic.LoadInt64(&old.Size)
			a.Total = atomic.LoadInt64(&old.Total)
			a.N = atomic.LoadInt64(&old.N)
			e.mu.Lock()
			e.addAll(t-1, a)
			e.mu.Unlock()
			acc = newAcc
		} else {
			// We may be able to grab the new accumulator by yielding.
			runtime.Gosched()
			acc = e.cached.Load()
		}
	}
	atomic.AddInt64(&acc.N, 1)
	atomic.AddInt64(&acc.Total, int64(value))
	atomic.AddInt64(&acc.Size, sz)

}

// Increase S3 total input bytes
func (s *connStats) incS3InputBytes(n int64) {
	atomic.AddUint64(&s.s3InputBytes, uint64(n))
}

// Increase S3 total output bytes
func (s *connStats) incS3OutputBytes(n int64) {
	atomic.AddUint64(&s.s3OutputBytes, uint64(n))
}

// Return S3 total input bytes
func (s *connStats) getS3InputBytes() uint64 {
	return atomic.LoadUint64(&s.s3InputBytes)
}

// Return S3 total output bytes

			"Total usable capacity online in current MinIO server instance",
			nil, nil),
		prometheus.GaugeValue,
		float64(GetTotalUsableCapacity(server.Disks, sinfo)),
	)

	// Report total usable capacity free
	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(
			prometheus.BuildFQName(minioNamespace, "capacity_usable_free", "total"),
			"Total free usable capacity online in current MinIO server instance",

    protected int currentPageNumber;

    /** The total number of records in the search result set. */
    protected long allRecordCount;

    /** The relation type for the total record count (e.g., "eq", "gte"). */
    protected String allRecordCountRelation;

    /** The total number of pages based on the page size and total record count. */
    protected int allPageCount;

            total = settings.size();
            return this;
        }

        /**
         * Sets the total number of configuration settings.
         * @param total The total number of configuration settings.
         * @return The ApiConfigsResponse instance.
         */
        public ApiConfigsResponse<T> total(final long total) {
            this.total = total;
            return this;