it does not call the loop body again after it has returned false or
after the entire loop has exited (it might retain a copy of the body
function, or pass it to another goroutine) -- each generated loop has
its own #stateK variable that is used to check for permitted call
patterns to the yield function for a loop body.

The state values are:

abi.RF_DONE = 0      // body of loop has exited in a non-panic way

        //   ApplyWeightUpdates_1 -> Computation_B
        //   ApplyWeightUpdates_2 -> Computation_C
        //   Computation_A -> NoOp
        //   Computation_B -> NoOp
        //   Computation_C -> NoOp
        //   "iteration++" -> NoOp
        // }
        //
        // In the graph above we can't cluster iteration++ with any of the

		for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop"
			if x == 4 { // ERROR "Branch prediction rule stay in loop"
				return a
			}
			for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop"
				for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop"
					a -= j * i
				}
				a += j
			}
		}
	}
	return a
}

// Checks that 2 `NoOp`s having control dependencies to each of the initializer
// functions are created.
// CHECK-DAG: %[[CTL_2:.*]] = tf_executor.island(%[[CTL_0]]) wraps "tf.NoOp"()
// CHECK-DAG: %[[CTL_3:.*]] = tf_executor.island(%[[CTL_1]]) wraps "tf.NoOp"()

// CHECK: tf_executor.fetch
// CHECK-SAME: !tf_executor.control, !tf_executor.control

// license that can be found in the LICENSE file.

package main

func f(j int) {
loop:
	for i := 0; i < 4; i++ {
		if i == 1 {
			continue loop
		}
		println(j, i)
	}
}

func main() {
loop:
	for j := 0; j < 5; j++ {
		f(j)
		if j == 3 {
			break loop
		}
	}

	ADD	X10, X11	// end

	PCALIGN	$16
loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15
	ADD	$1, X10
	BNE	X12, X15, loop
	ADD	$1, X14
	JMP	loop

done:
	MOV	X14, X10
	RET

TEXT ·CountString<ABIInternal>(SB),NOSPLIT,$0-32
	// X10 = s_base
	// X11 = s_len
	// X12 = byte to count
	AND	$0xff, X12
	MOV	ZERO, X14	// count
	ADD	X10, X11	// end

	PCALIGN	$16
loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15

				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"int8", ValueOf(int8(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := int8(0)
			for v := range s {
				if v.Interface().(int8) != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},

// Does not compile.

package main

var x int

func f1() {
	switch x {
	case 1:
		continue // ERROR "continue is not in a loop$|continue statement not within for"
	}
	select {
	default:
		continue // ERROR "continue is not in a loop$|continue statement not within for"
	}

}

func f2() {
L1:
	for {
		if x == 0 {
			break L1
		}
		if x == 1 {
			continue L1
		}

		fmt.Println("defer")
	}()
label:
	fmt.Println("goto loop")
	if glob > 2 {
		goto label
	}
}

func f5() {
label:
	fmt.Println("goto loop")
	defer func() { // ERROR "heap-allocated defer"
		fmt.Println("defer")
	}()
	if glob > 2 {
		goto label
	}
}

func f6() {
label:
	fmt.Println("goto loop")
	if glob > 2 {
		goto label
	}

// Utility functions for constructing while loop gradients

namespace tensorflow {

// Adds the gradient computation for the while loop associated with
// `while_ctx`. `grad_inputs` are the partial derivatives w.r.t. the loop
// outputs, i.e. the exit nodes.  The partial derivatives w.r.t. the loop
// inputs, i.e. the input loop vars, are returned in `grad_outputs`.