func NewNoneEndpointReconciler() EndpointReconciler {
	return &noneEndpointReconciler{}
}

// ReconcileEndpoints noop reconcile
func (r *noneEndpointReconciler) ReconcileEndpoints(serviceName string, ip net.IP, endpointPorts []corev1.EndpointPort, reconcilePorts bool) error {
	return nil
}

// RemoveEndpoints noop reconcile

}  // namespace

// Add numbers in a loop by calling a callable.
void CallFunctions(::testing::benchmark::State& state) {
  Integer sum(0);
  Callable callable((impl::TaggedValue(impl::Func(AddTagged))));
  *callable.Call<Integer>(sum, Integer(30));
  size_t i = 0;
  for (auto dummy : state) {
    sum = *callable.Call<Integer>(sum, Integer(i));
    i++;
  }
}

// Add numbers in a loop by calling a callable, looking up method every

    value {
      list {
        shape {
          unknown_rank: true
        }
        shape {
          unknown_rank: true
        }
      }
    }
  }
}
node {
  name: "NoOp"
  op: "NoOp"
  input: "^cluster/pivot"
  attr {
    key: "_tpu_replicate"
    value {
      s: "cluster"
    }
  }
}
node {
  name: "Identity"
  op: "Identity"
  input: "cond"

// getLoopDeviceFromSysfs finds the backing file for a loop
// device from sysfs via "/sys/block/loop*/loop/backing_file".
func getLoopDeviceFromSysfs(path string) (string, error) {
	// If the file is a symlink.
	realPath, err := filepath.EvalSymlinks(path)
	if err != nil {
		return "", fmt.Errorf("failed to evaluate path %s: %s", path, err)
	}

	devices, err := filepath.Glob("/sys/block/loop*")
	if err != nil {

    %control_2 = tf_executor.island wraps "tf.NoOp"() {_pivot_for_cluster = "cluster", device = ""} : () -> ()
    // CHECK: %control_3 = tf_executor.island(%control_2) wraps "tf.NoOp"() {_tpu_replicate = "cluster", device = ""} : () -> ()
    %control_3 = tf_executor.island(%control_2) wraps "tf.NoOp"() {_replication_info = "cluster", _xla_compile_device_type = "TPU", device = ""} : () -> ()

// However, checking i < len(x) && i < len(y) as well is faster than
// having the compiler do a bounds check in the body of the loop;
// remarkably it is even faster than hoisting the bounds check
// out of the loop, by doing something like
//   _, _ = x[len(z)-1], y[len(z)-1]
// There are other ways to hoist the bounds check out of the loop,
// but the compiler's BCE isn't powerful enough for them (yet?).
// See the discussion in CL 164966.

	MOVBZ  ·useAsm(SB), R4
	LMG    dig+0(FP), R1, R3            // R2 = &p[0], R3 = len(p)
	MOVBZ  $1, R0                       // SHA-1 function code
	CMPBEQ R4, $0, generic

loop:
	KIMD R0, R2      // compute intermediate message digest (KIMD)
	BVS  loop        // continue if interrupted
	RET

generic:

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

package a

func Unique[T comparable](set []T) []T {
	nset := make([]T, 0, 8)

loop:
	for _, s := range set {
		for _, e := range nset {
			if s == e {
				continue loop
			}
		}

		nset = append(nset, s)
	}

	return nset

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

package main

func main() {
	L: ;  // ';' terminates empty statement => L does not apply to for loop
	for i := 0; i < 10; i++ {
		println(i);
		break L;  // ERROR "L"
	}

	L1: { // L1 labels block => L1 does not apply to for loop
		for i := 0; i < 10; i++ {
			println(i);
			break L1;  // ERROR "L1"
		}
	}

	// 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
}