}
		}
		m.tlock.RUnlock()

	}
	return report
}

func (m *Monitor) trackEWMA() {
	for {
		select {
		case <-m.bucketMovingAvgTicker.C:
			m.updateMovingAvg()
		case <-m.ctx.Done():
			return
		}
	}
}

func (m *Monitor) updateMovingAvg() {
	m.mlock.Lock()
	defer m.mlock.Unlock()
	for _, bucketMeasurement := range m.bucketsMeasurement {

	}
	r.onReaderExit = func() {
		close(r.decoded)
		readCloser.Close()
		for range r.input {
			// Read until EOF trickles through.
			// Otherwise, we risk the decoder hanging.
		}
		r.readerWg.Done()
	}

	// We cannot reuse as we are sending parsed objects elsewhere.
	simdjson.ParseNDStream(readCloser, r.input, nil)
	r.readerWg.Add(1)
	go r.startReader()
	return &r
}

            determineSubProjectClassTimes(testCoverage, buildProjectClassTimes)?.toMutableMap() ?: return validSubprojects.map { SmallSubprojectBucket(it, ParallelizationMethod.None) }

        validSubprojects.forEach {
            if (!subProjectToClassTimes.containsKey(it.name)) {
                subProjectToClassTimes[it.name] = emptyList()
            }
        }

        val parallelizationMethod = when (testCoverage.os) {
            Os.LINUX -> ParallelizationMethod.TestDistribution
            else -> ParallelizationMethod.None
        }

        return FunctionalTest(
            model,
            testCoverage.getBucketUuid(model, bucketIndex),
            "${testCoverage.asName()} ($startInclusive <= gradle <$endExclusive)",

        tasks.named("test", Test.class).configure(task -> {
            task.getInputs().file(extension.getReleaseNotes().getRenderedDocumentation()).withPropertyName("releaseNotes").withPathSensitivity(PathSensitivity.NONE);

            task.getInputs().property("systemProperties", Collections.emptyMap());
            // TODO: This breaks the provider

        super.processCleanupCrawling(objs);
        if (objs.length > 1 && objs[1] instanceof final UrlQueue<?> urlQueue) {
            ComponentUtil.getCrawlerStatsHelper().done(urlQueue);
        }
    }

    @Override
    protected void processProcessChildUrlByException(final Object... objs) {
        super.processProcessChildUrlByException(objs);

    }
    return size;
  }

  @Override
  public boolean containsKey(@CheckForNull Object key) {
    if (unfiltered.containsKey(key)) {
      @SuppressWarnings("unchecked") // k is equal to a K, if not one itself
      K k = (K) key;
      return keyPredicate.apply(k);
    }
    return false;
  }

  @Override
  public Collection<V> removeAll(@CheckForNull Object key) {

import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A sorted map which forwards all its method calls to another sorted map. Subclasses should
 * override one or more methods to modify the behavior of the backing sorted map as desired per the
 * <a href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

		s := strings.Index(fwd, ", ")
		if s == -1 {
			s = len(fwd)
		}
		addr = fwd[:s]
	} else if fwd := r.Header.Get(xRealIP); fwd != "" {
		// X-Real-IP should only contain one IP address (the client making the
		// request).
		addr = fwd
	} else if fwd := r.Header.Get(forwarded); fwd != "" {
		// match should contain at least two elements if the protocol was