}
        """)
        withFile("buildSrc/src/main/kotlin/my-plugin.gradle.kts", """
            extensions.create<MyExtension>("my")
            tasks.register("noop")
        """)
        withBuildScript("""
            plugins { id("my-plugin") }

            extensions.getByType(MyExtension::class).some("api.get")

    public void visitForLoop(ForStatement forLoop) {
        restrict(forLoop);
    }

    @Override
    public void visitWhileLoop(WhileStatement loop) {
        restrict(loop);
    }

    @Override
    public void visitDoWhileLoop(DoWhileStatement loop) {
        restrict(loop);
    }

    @Override
    public void visitIfElse(IfStatement ifElse) {
        restrict(ifElse);
    }

    @Override

	// RemoveEndpoints removes this apiserver's peer endpoint lease.
	RemoveLease(serverId string) error
	// Destroy cleans up everything on shutdown.
	Destroy()
	// StopReconciling turns any later ReconcileEndpoints call into a noop.
	StopReconciling()
}

type peerEndpointLeaseReconciler struct {
	serverLeases          *peerEndpointLeases
	stopReconcilingCalled atomic.Bool
}

		// or the other of hp and hu as the loop proceeds.
		//
		// hp is live during most of the body of the loop. But it isn't live
		// at the very top of the loop, when we haven't checked i<n yet, and
		// it could point off the end of the backing store.
		// hu is live only at the very top and very bottom of the loop.
		// In particular, only when it cannot possibly be live across a call.
		//

The "range" clause in a "for-range" loop now accepts iterator functions of the following types

	func(func() bool)
	func(func(K) bool)
	func(func(K, V) bool)

as range expressions.
Calls of the iterator argument function produce the iteration values for the "for-range" loop.
For details see the [language spec](/ref/spec#For_statements).

// findIndVar finds induction variables in a function.
//
// Look for variables and blocks that satisfy the following
//
//	 loop:
//	   ind = (Phi min nxt),
//	   if ind < max
//	     then goto enter_loop
//	     else goto exit_loop
//
//	   enter_loop:
//		do something
//	      nxt = inc + ind
//		goto loop
//
//	 exit_loop:
func findIndVar(f *Func) []indVar {
	var iv []indVar
	sdom := f.Sdom()

			// check that RET wasn't overwritten.
			if bytes.Contains(data[idx], []byte("RET")) {
				if testing.Short() {
					break LOOP
				}
				continue LOOP
			}
		}
		t.Errorf("VMOVUPS zeros<>(SB), %s overwrote RET", reg)
	}

// ultimate source of v.  v must be a copy op.
func copySource(v *Value) *Value {
	w := v.Args[0]

	// This loop is just:
	// for w.Op == OpCopy {
	//     w = w.Args[0]
	// }
	// but we take some extra care to make sure we
	// don't get stuck in an infinite loop.
	// Infinite copy loops may happen in unreachable code.
	// (TODO: or can they? Needs a test.)
	slow := w
	var advance bool

        }
        reload
        loop
        bind __PILLAR__LOCAL__DNS__ __PILLAR__DNS__SERVER__
        forward . __PILLAR__CLUSTER__DNS__ {
                force_tcp
        }
        prometheus :9253
        health __PILLAR__LOCAL__DNS__:8080
        }
    in-addr.arpa:53 {
        errors
        cache 30
        reload
        loop
        bind __PILLAR__LOCAL__DNS__ __PILLAR__DNS__SERVER__

// func kdsa(fc uint64, params *[4096]byte) (errn uint64)
TEXT ·kdsa(SB), NOSPLIT|NOFRAME, $0-24
	MOVD fc+0(FP), R0     // function code
	MOVD params+8(FP), R1 // address parameter block

loop:
	KDSA R0, R4      // compute digital signature authentication
	BVS  loop        // branch back if interrupted
	BGT  retry       // signing unsuccessful, but retry with new CSPRN
	BLT  error       // condition code of 1 indicates a failure

success: