}
            }
        }
        matches
    }

    List<BuildOperationRecord.Progress> progress(Class<?> clazz) {
        return all().collect { it.progress(clazz) }.flatten()
    }

    void walk(Action<? super BuildOperationRecord> action) {
        roots.each { walk(it, action) }
    }

    @SuppressWarnings("GrMethodMayBeStatic")

                                    }
                                }
                            }
                        }
                    }
                } else if (dependencies || !variants.dependencies.flatten().empty) {
                    dependencies {
                        dependencies.each { dep ->
                            dependency {
                                groupId(dep.groupId)

		if p.Port == port {
			pn = p.Name
			break
		}
	}
	if pn == "" && port != 0 {
		return nil
	}
	shards.RLock()
	defer shards.RUnlock()
	return slices.FilterInPlace(slices.Flatten(maps.Values(shards.Shards)), func(endpoint *model.IstioEndpoint) bool {
		return pn == "" || endpoint.ServicePortName == pn
	})
}

    return durationsPerTestProject
        .mapValues { (_, durations) -> durations.flatten().map { it.scenario } }
}

class EmptyTestProjectBucket(private val index: Int) : PerformanceTestBucket {
    override

        val subprojectRoots = File("../platforms").listFiles(File::isDirectory).plus(File("../subprojects"))
        val subProjectFolders = subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten().filter { dir ->
            // filter out the directories that have only a `build` subdirectory - this usually happens after branch switching
            dir.listFiles { _: File, name: String -> name != "build" }!!.isNotEmpty()

            return causes
        }

        @Override
        List<String> getResolutions() {
            return causes.collect { it instanceof ResolutionProvider ? ((ResolutionProvider) it).getResolutions() : null }.flatten() as List<String>
        }
    }

    @Contextual
    abstract static class TestException extends LocationAwareException {
        protected TestException(Throwable cause, ScriptSource source, Integer lineNumber) {

  "TFL::IsReducedTailOfShape($0.getType(), $1.getType())">>;

def IsRankLessThanEqualTo : Constraint<CPred<
  "$0.getType().cast<ShapedType>().getRank() <= "
  "$1.getType().cast<ShapedType>().getRank()">>;

def Flatten : NativeCodeCall<
  "$0.cast<DenseElementsAttr>()"
    ".reshape(RankedTensorType::get({$0.getType().cast<ShapedType>().getNumElements()}, "
                                   "$0.getType().cast<ShapedType>().getElementType()))">;

			input: [][]int{{1, 2}, {}, {3, 4}},
			want:  []int{1, 2, 3, 4},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			got := Flatten(tc.input)
			if !reflect.DeepEqual(got, tc.want) {
				t.Errorf("Flatten(%v) = %v; want %v", tc.input, got, tc.want)
			}
		})
	}
}

// nolint: unused
type myStruct struct {
	a, b, c, d string
	n          int
}

    }

    /**
     * Recursively unpacks all the given things into a flat list.
     *
     * Nulls are not removed, they are left intact.
     *
     * @param things The things to flatten
     * @return A flattened list of the given things
     */
    public static List<?> flattenCollections(Object... things) {
        return flattenCollections(Object.class, things);
    }

    /**

			cc.PodMaxBackoffSeconds, "must be greater than or equal to PodInitialBackoffSeconds"))
	}

	errs = append(errs, validateExtenders(field.NewPath("extenders"), cc.Extenders)...)
	return utilerrors.Flatten(utilerrors.NewAggregate(errs))
}

func validatePercentageOfNodesToScore(path *field.Path, percentageOfNodesToScore *int32) error {
	if percentageOfNodesToScore != nil {