{29, "SIGPWR", "power-failure"},
	{30, "SIGUSR1", "user defined signal 1"},
	{31, "SIGUSR2", "user defined signal 2"},
	{32, "SIGPROF", "profiling timer expired"},
	{33, "SIGDANGER", "paging space low"},
	{34, "SIGVTALRM", "virtual timer expired"},
	{35, "SIGMIGRATE", "signal 35"},
	{36, "SIGPRE", "signal 36"},
	{37, "SIGVIRT", "signal 37"},
	{38, "SIGTALRM", "signal 38"},

	{29, "SIGPWR", "power-failure"},
	{30, "SIGUSR1", "user defined signal 1"},
	{31, "SIGUSR2", "user defined signal 2"},
	{32, "SIGPROF", "profiling timer expired"},
	{33, "SIGDANGER", "paging space low"},
	{34, "SIGVTALRM", "virtual timer expired"},
	{35, "SIGMIGRATE", "signal 35"},
	{36, "SIGPRE", "signal 36"},
	{37, "SIGVIRT", "signal 37"},
	{38, "SIGTALRM", "signal 38"},

	// to this, since the generated code can be more efficient,
	// but comes at the cost of having a large L2 mapping.
	//
	// We use the L1 map on 64-bit Windows because the arena size
	// is small, but the address space is still 48 bits, and
	// there's a high cost to having a large L2.
	arenaL1Bits = 6 * (_64bit * goos.IsWindows)

	// arenaL2Bits is the number of bits of the arena number

	{
		Value:     &PointerAnonFields{},
		ExpectXML: `<PointerAnonFields></PointerAnonFields>`,
	},

	// Test that name casing matters
	{
		Value:     &NameCasing{Xy: "mixed", XY: "upper", XyA: "mixedA", XYA: "upperA"},
		ExpectXML: `<casing Xy="mixedA" XY="upperA"><Xy>mixed</Xy><XY>upper</XY></casing>`,
	},

	// Test the order in which the XML element name is chosen
	{
		Value: &NamePrecedence{

        def providerWithSideEffect = Providers.of(someValue()).withSideEffect(sideEffect)
        // `PropertyInternal` does not directly provide these setters,
        // but all user-facing interfaces and their implementations do.
        property."$setter"(providerWithSideEffect)

        property.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)
        property.calculateExecutionTimeValue()

//	    }
//	    // Unordered output: 4
//	    // 2
//	    // 1
//	    // 3
//	    // 0
//	}
//
// Example functions without output comments are compiled but not executed.
//
// The naming convention to declare examples for the package, a function F, a type T and
// method M on type T are:
//
//	func Example() { ... }
//	func ExampleF() { ... }
//	func ExampleT() { ... }
//	func ExampleT_M() { ... }

	//
	// Stop if we're preemptible, if someone wants to STW, or if
	// someone is calling forEachP.
	//
	// TODO(mknyszek): Consider always checking gp.preempt instead
	// of having the preempt flag, and making an exception for certain
	// mark workers in retake. That might be simpler than trying to
	// enumerate all the reasons why we might want to preempt, even
	// if we're supposed to be mostly non-preemptible.

	// file table is already de-duped.
	for i, name := range unit.FileTable {
		name := expandFile(name)
		if len(name) == 0 {
			// Can't have empty filenames, and having a unique
			// filename is quite useful for debugging.
			name = fmt.Sprintf("<missing>_%d", i)
		}
		// Note the use of "path" here and not "filepath". The compiler

If a build configuration input has changed, Gradle will not use the entry and will run the configuration phase again as above, saving the result for later reuse.

Build configuration inputs include:

- Init scripts
- Settings scripts
- Build scripts
- System properties used during the configuration phase

   * any of the provided futures fails or is canceled, its corresponding position will contain
   * {@code null} (which is indistinguishable from the future having a successful value of {@code
   * null}).
   *
   * <p>The list of results is in the same order as the input list.
   *
   * <p>This differs from {@link #allAsList(ListenableFuture[])} in that it's tolerant of failed