A "percentile" is a statistical concept that represents the value below
    which a given percentage of data falls in a dataset. It involves sorting the
    data from smallest to largest and then finding the value at a specified
    percentage position. For example, the 0.01 percentile represents the value
    in a given data set that corresponds to the lowest 0.01% of the data.

    justify-content: space-between;
    max-width: 75rem;
    margin-left: auto;
    margin-right: auto;
    font-size: 0.875rem;
    padding: 0.5rem 0.75rem;
}

/*
 * 1. Value is the largest computed width among 'site-footer__copy' and 'site-footer__links'.
 */
.site-footer__copy,
.site-footer__secondary-links {
    flex-grow: 0;
    flex-basis: 280px;
    /* 1. */
}

/*

Gradle's build cache can be very useful in reducing CI infrastructure cost and feedback time, but it usually has the biggest impact when developers can reuse cached results in their local builds. This is also the hardest to quantify for a number of reasons:

* developers run different builds
* developers can have different hardware, or have different settings
* developers run all kinds of other things on their machines that can slow them down

	r.mu.RLock()
	defer r.mu.RUnlock()
	return r.status[key]
}

// Register that a dataplane has acknowledged a new version of the config.
// Theoretically, we could use the ads connections themselves to harvest this data,
// but the mutex there is pretty hot, and it seems best to trade memory for time.
func (r *Reporter) RegisterEvent(conID string, distributionType xds.EventType, nonce string) {
	if nonce == "" {
		return
	}

func (c *MetaAllocator) getAllocator(ip net.IP) (*Allocator, error) {
	c.muTree.Lock()
	defer c.muTree.Unlock()

	address := ipToAddr(ip)
	prefix := netip.PrefixFrom(address, address.BitLen())
	// Use the largest subnet to allocate addresses because
	// all the other subnets will be contained.
	_, allocator, ok := c.tree.ShortestPrefixMatch(prefix)
	if !ok {
		klog.V(2).Infof("Could not get allocator for IP %s", ip.String())

// total samples collected.
func (p *Profile) Merge(pb *Profile, r float64) error {
	if err := p.Compatible(pb); err != nil {
		return err
	}

	pb = pb.Copy()

	// Keep the largest of the two periods.
	if pb.Period > p.Period {
		p.Period = pb.Period
	}

	p.DurationNanos += pb.DurationNanos

	p.Mapping = append(p.Mapping, pb.Mapping...)
	for i, m := range p.Mapping {

func Offsetof(x ArbitraryType) uintptr

// Alignof takes an expression x of any type and returns the required alignment
// of a hypothetical variable v as if v was declared via var v = x.
// It is the largest value m such that the address of v is always zero mod m.
// It is the same as the value returned by [reflect.TypeOf](x).Align().
// As a special case, if a variable s is of struct type and f is a field

// Generates many inputs, builds and checks suffix arrays.
func test(t *testing.T, build func([]byte) []int) {
	t.Run("ababab...", func(t *testing.T) {
		// Very repetitive input has numLMS = len(x)/2-1
		// at top level, the largest it can be.
		// But maxID is only two (aba and ab$).
		size := 100000
		if testing.Short() {
			size = 10000
		}
		x := make([]byte, size)
		for i := range x {
			x[i] = "ab"[i%2]
		}

	// prefers setCounts to be sorted for optimal behavior.
	if divisibleSize < setCounts[len(setCounts)-1] {
		return divisibleSize
	}

	// Figure out largest value of total_drives_in_erasure_set which results
	// in least number of total_drives/total_drives_erasure_set ratio.
	prevD := divisibleSize / setCounts[0]
	for _, cnt := range setCounts {
		if divisibleSize%cnt == 0 {

   * @since 20.0
   */
  public static BigInteger ceilingPowerOfTwo(BigInteger x) {
    return BigInteger.ZERO.setBit(log2(x, CEILING));
  }

  /**
   * Returns the largest power of two less than or equal to {@code x}. This is equivalent to {@code
   * BigInteger.valueOf(2).pow(log2(x, FLOOR))}.
   *
   * @throws IllegalArgumentException if {@code x <= 0}
   * @since 20.0
   */