path:   "/nested-key1",
							allow:  true,
						},
						{
							prefix: "[NestedToken2]",
							jwt:    jwt.TokenIssuer1WithNestedClaims2,
							path:   "/nested-key1",
							allow:  false,
						},
						{
							prefix: "[NestedToken1]",
							jwt:    jwt.TokenIssuer1WithNestedClaims1,
							path:   "/nested-key2",
							allow:  false,
						},
						{

// CHECK:      %[[CLUSTER:[0-9]*]]:3 = "tf_device.cluster"() ({
// CHECK-NEXT:   %[[OP_A:[0-9]*]] = "tf.opA"(%[[ARG_0]])
// CHECK-NEXT:   %[[OP_C:[0-9]*]] = "tf.opC"(%[[OP_A]])
// CHECK-NEXT:   %[[OP_D:[0-9]*]] = "tf.opD"(%[[OP_C]])
// CHECK-NEXT:   %[[OP_F:[0-9]*]] = "tf.opF"(%[[ARG_0]])
// CHECK-NEXT:   tf_device.return %[[OP_C]], %[[OP_D]], %[[OP_F]]
// CHECK-NEXT: _replication_info = "replicate"
// CHECK-SAME: device = "/device:TPU:0"

            }
            // also check interfaces in case we have interfaces with nested classes
            for (ClassNode next : classToCheck.getAllInterfaces()) {
                if (type.getName().contains(next.getName())) {
                    continue;
                }
                val = new ConstructedNestedClass(next, type.getName());
                if (resolve(val, false, false, false)) {

			expectedSetCost:  25165826,
		},
		{
			name:             "nested types with root rule with all supporting maxLength",
			schemaGenerator:  genAllMaxNestedSpecWithRootRule(`self.all(x, x["y"].required == "z")`),
			expectedCalcCost: 7340027,
			setMaxElements:   10,
			expectedSetCost:  72,
		},
		{
			name:             "nested types with root rule with one supporting maxLength",

[.multi-language-sample]
=====
[source,kotlin]
----
.
├── settings.gradle.kts
└── nested
    ├── settings.gradle.kts
    └── nestedNested
        └── settings.gradle.kts
----
.settings.gradle.kts
[source,kotlin]
----
includeBuild("nested")
----
.nested/settings.gradle.kts
[source,kotlin]
----
includeBuild("nestedNested")
----
=====
[.multi-language-sample]
=====
[source,groovy]
----

import org.gradle.api.tasks.InputDirectory
import org.gradle.api.tasks.InputFile
import org.gradle.api.tasks.InputFiles
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.LocalState
import org.gradle.api.tasks.Nested
import org.gradle.api.tasks.Optional
import org.gradle.api.tasks.OutputDirectories
import org.gradle.api.tasks.OutputDirectory
import org.gradle.api.tasks.OutputFile
import org.gradle.build.event.BuildEventsListenerRegistry

// upstream frames are populated.  In effect, this order enables processing each
// (nested) tf.while one-by-one, as each (nested) tf.while creates a unique
// (root) frame.  Note that we don't separate while loops belonging to the same
// nested while, as there is no clean cut for separating them in the topological
// order.
Status DeadnessAnalysisImpl::Populate(bool enable_optimistic) {

		}

		for pcsp.Init(d.linkctxt.loader.Data(fpcsp)); !pcsp.Done; pcsp.Next() {
			nextpc := pcsp.NextPC

			// pciterinit goes up to the end of the function,
			// but DWARF expects us to stop just before the end.
			if int64(nextpc) == int64(len(d.ldr.Data(fn))) {
				nextpc--
				if nextpc < pcsp.PC {
					continue
				}
			}

			spdelta := int64(pcsp.Value)

            }
        '''.stripIndent()

        when:
        run 'copy'

        then:
        def it = file('dest/two.a').readLines().iterator()
        it.next().startsWith('6')
        it.next().startsWith('11')
        it.next().startsWith('16')
    }

    def "can rename files in eachFile() action defined using Groovy closure"() {
        given:
        file('files/a.txt').createFile()

}
```
### `-tf-executor-tpu-v1-island-outlining`

_Outline TPU clusters from island into a nested module, so it can be processed like a V2 module, intended for V1 compatibility mode_

Extract the islands containing a TPU cluster computation into an outlined
function in a nested module. This will allow to run the usual bridge on this
nested module which now exhibits a more friendly "V2-like" structure.