}).wasInterrupted()) {
      ops_with_side_effects.push_back(&op);
    }
  }

  OpBuilder builder(fn.getContext());
  // The control tokens generated by the last ControlNodeOp wrapping.  Will be
  // empty until the first ControlNodeOp was generated, then have constant size
  // 1.
  llvm::SmallVector<Value, 1> control_tokens;
  for (auto *op : ops_with_side_effects) {

        normalizedOutput
            .replaceAll(/Received \d+ file system events .*\n/, '')
            .replaceAll(/Spent \d+ ms processing file system events since last build\n/, '')
            .replaceAll(/Spent \d+ ms registering watches for file system events\n/, '')
            .replaceAll(/Virtual file system .*\n/, '')
    }

                while (true) {
                    type = decoder.readByte();
                    valuesRead++;
                    switch (type) {
                        case ROOT:
                            // Last entry, complete the result
                            Long rootId = decoder.readSmallLong();
                            builder.addDependencyLockingFailures(rootId, dependencyLockingFailures);

  }

  /**
   * Moves the last entry in the entry array into {@code dstIndex}, and nulls out its old position.
   */
  void moveLastEntry(int dstIndex, int mask) {
    Object table = requireTable();
    int[] entries = requireEntries();
    @Nullable Object[] elements = requireElements();
    int srcIndex = size() - 1;
    if (dstIndex < srcIndex) {
      // move last entry to deleted spot

			})

			// Summarize them.
			var events []event
			last := t.startTime()
			for _, ev := range rawEvents {
				what := describeEvent(ev)
				if what == "" {
					continue
				}
				sinceStart := ev.Time().Sub(t.startTime())
				events = append(events, event{
					WhenString: fmt.Sprintf("%2.9f", sinceStart.Seconds()),
					Elapsed:    ev.Time().Sub(last),
					What:       what,
					Goroutine:  primaryGoroutine(ev),

            .groupBy { "${it.major}.${it.minor}" }
            .map { (_, v) -> v.maxOrNull()!!.format() }

        // Limit to first and last release of each major version
        mainTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { it.major }

    is AnalysisStatementFilter.NotFilter -> !negationOf.shouldAnalyzeStatement(statement, scopes)
    is AnalysisStatementFilter.TopLevelElementFilter -> scopes.last().receiver is ObjectOrigin.TopLevelReceiver
}


internal
object AnalysisStatementFiltersImplementations {
    class DefaultAnalyzeEverythingFilter : AnalysisStatementFilter.AnalyzeEverythingFilter

import kotlin.reflect.KClass
import kotlin.reflect.full.memberFunctions


/**
 * Provides type discovery via functions that return an object or configure an object accepting a lambda as the last parameter
 * (via [org.gradle.api.Action] or a Kotlin function type, see [gradleConfigureLambdas]).
 *

// GoStatus event.
//
// The situation is one in which it just so happens that
// an event on the frontier for a following generation
// has a sequence number exactly one higher than the last
// sequence number for e.g. a goroutine in the previous
// generation. The parser should wait to find a GoStatus
// event before advancing into the next generation at all.

					best.cached = xl
				}
			}
			toMerge = toMerge[:0]
		}
		if best.name > last {
			select {
			case <-ctxDone:
				return ctx.Err()
			case out <- *best:
				last = best.name
			}
		} else if serverDebugLog {
			console.Debugln("mergeEntryChannels: discarding duplicate", best.name, "<=", last)
		}
		// Replace entry we just sent.
		if err := selectFrom(bestIdx); err != nil {
			return err