// This test is to test for unranked function output from input, the output type should be compatible with input type.

// CHECK: func @main(%arg0: tensor<1xf32>) -> tensor<*xf32> attributes {tf.entry_function = {inputs = "arg0", outputs = "tfl.while"}} {
// CHECK:   %0 = "tfl.while"(%arg0) ({

  func.return %1 : tensor<i32>
}

// CHECK-LABEL: func @set_stateless
func.func @set_stateless(%arg: tensor<i32>, %cond: tensor<i1>) -> (tensor<i32>, tensor<i32>) {
  // CHECK: tf.While
  // CHECK-SAME: is_stateless = true
  %0 = "tf.While"(%arg) { cond = @no_side_effect_cond, body = @no_side_effect_body, is_stateless = false} : (tensor<i32>) -> (tensor<i32>)
  // CHECK: tf.If
  // CHECK-SAME: is_stateless = true

    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "while"
  op: "While"
  input: "while/loop_counter"
  input: "while/maximum_iterations"
  input: "input"
  attr {
    key: "T"
    value {
      list {
        type: DT_INT32
        type: DT_INT32
        type: DT_INT32
      }
    }

	if err != nil {
		t.Fatalf("Error while calling GetTrustAnchorsByName: %v", err)
	}

	if diff := diffBundles(gotBundle, []byte(ctb1.Spec.TrustBundle)); diff != "" {
		t.Fatalf("Got bad bundle; diff (-got +want)\n%s", diff)
	}

	gotBundle, err = ctbManager.GetTrustAnchorsByName("ctb2", false)
	if err != nil {
		t.Fatalf("Error while calling GetTrustAnchorsByName: %v", err)
	}

   * {@code key} while the new value was loading then a removal notification will be sent for the
   * new value.
   *
   * <p>If the cache loader associated with this cache is known not to throw checked exceptions,
   * then prefer {@link #getUnchecked} over this method.
   *
   * @throws ExecutionException if a checked exception was thrown while loading the value. ({@code

// CHECK-NEXT: Tensor 3 tfl.while kTfLiteInt32 kTfLiteArenaRw 4 / 0.00 (null) [{{.*}})
// CHECK-NEXT: Tensor 4 result kTfLiteFloat32 kTfLiteArenaRw 4 / 0.00 [1] [{{.*}})

// Verify while was not folded away:
// ------------------------------------
// CHECK: Operator Builtin Code {{[0-9]*}} WHILE

func.func @main() -> (tensor<1xf32>, tensor<i32>)

module attributes {tf.versions = {producer = 888 : i32}} {
// CHECK-LABEL: func @while_main
// CHECK: %0 = "tf.While"(%arg0)
// CHECK-SAME: body = @while_body
// CHECK-SAME: cond = @while_cond
// CHECK: "tf.While"(%arg1)
// CHECK-SAME: body = @while_body_0
// CHECK-SAME: cond = @while_cond_1

// CHECK: func @while_body(%arg0: tensor<256x256xi32>)

        var it: Node = null

        it = head
        while (it != null && it.next != null) {
            it = it.next
        }

        it
    }

    def remove(element: String): Boolean = {
        var result = false
        var previousIt: Node = null
        var it: Node = head
        while (!result && it != null) {
            if (0 == element.compareTo(it.data)) {

     */
    T get();

    /**
     * Sets the value for this cache. An exclusive lock is held while setting the value.
     */
    void set(T newValue);

    /**
     * Replaces the value for this cache.
     *
     * An exclusive lock is held while the update action is executing.

void lockOSThreadC(void) {
	lockOSThreadCallback();
}

void issue7978c(uint32_t *sync) {
	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 0)
		;
	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 2)
		;
	issue7978cb();
	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 6)
		;
}

void f7665(void) {