rngVec[i] = u
		}
	}
}

func vrand() int64 {
	rngTap--
	if rngTap < 0 {
		rngTap += length
	}
	rngFeed--
	if rngFeed < 0 {
		rngFeed += length
	}
	x := (rngVec[rngFeed] + rngVec[rngTap])
	rngVec[rngFeed] = x
	return x
}

func main() {
	srand(1)
	for i := uint64(0); i < 7.8e12; i++ {
		vrand()
	}
	fmt.Printf("rngVec after 7.8e12 calls to vrand:\n%#v\n", rngVec)
	for i := range rngVec {

	"I32Mul",
	"I32DivS",
	"I32DivU",
	"I32RemS",
	"I32RemU",
	"I32And",
	"I32Or",
	"I32Xor",
	"I32Shl",
	"I32ShrS",
	"I32ShrU",
	"I32Rotl",
	"I32Rotr",
	"I64Clz",
	"I64Ctz",
	"I64Popcnt",
	"I64Add",
	"I64Sub",
	"I64Mul",
	"I64DivS",
	"I64DivU",
	"I64RemS",
	"I64RemU",
	"I64And",
	"I64Or",
	"I64Xor",
	"I64Shl",
	"I64ShrS",
	"I64ShrU",

}

// New returns a new Rand that uses random values from src
// to generate other random values.
func New(src Source) *Rand {
	return &Rand{src: src}
}

// Int64 returns a non-negative pseudo-random 63-bit integer as an int64.
func (r *Rand) Int64() int64 { return int64(r.src.Uint64() &^ (1 << 63)) }

// Uint32 returns a pseudo-random 32-bit value as a uint32.
func (r *Rand) Uint32() uint32 { return uint32(r.src.Uint64() >> 32) }

  // Collect operands for the new merged island.
  island_operands_and_results.operands.clear();
  for (IslandOp island : merged_island.islands)
    island_operands_and_results.operands.insert(island.operand_begin(),
                                                island.operand_end());
  for (IslandOp island : merged_island.islands)
    island_operands_and_results.operands.remove(island.getControl());

    // CHECK: %[[ADD:.*]], %{{.*}} = tf_executor.island wraps "tf.Add"(%[[ARG_2]], %[[ARG_3]]) : (tensor<f32>, tensor<f32>) -> tensor<f32>
    %add, %add_control = tf_executor.island wraps "tf.Add"(%arg2, %arg3) : (tensor<f32>, tensor<f32>) -> tensor<f32>
    // CHECK: %[[MUL:.*]], %{{.*}} = tf_executor.island wraps "tf.Mul"(%[[ARG_2]], %[[ARG_3]]) : (tensor<f32>, tensor<f32>) -> tensor<f32>

    }
    tf_executor.NextIteration.Sink[%source#1] %island#0 : tensor<*xi32>
    tf_executor.fetch %island#0 : tensor<*xi32>
  }
  func.return
}

// CHECK: %[[CONTROL:[^ ,]*]] = tf_executor.island wraps "tf.Print"
// CHECK: tf_executor.LoopCond {{.*}}, %[[CONTROL]]
func.func @loop_cond_control_input() {
  tf_executor.graph {
    %island:2 = tf_executor.island {

}

// CHECK: [[OUTPUT_0:%.*]], {{%.*}} = tf_executor.island wraps "tf.opA"() {_parallel_execution_ids = "p0:0"}
// CHECK: [[OUTPUT_1:%.*]], {{%.*}} = tf_executor.island wraps "tf.opB"([[OUTPUT_0:%.*]]) {_parallel_execution_ids = "p0:0"}
// CHECK: [[OUTPUT_2:%.*]], {{%.*}} = tf_executor.island wraps "tf.opC"() {_parallel_execution_ids = "p0:1"}

    // CHECK: %[[control:.*]] = tf_executor.island wraps "tf.A"()
    tf_executor.island wraps "tf.A"() : () -> ()
    // CHECK-NEXT: %[[control_2:.*]] = tf_executor.island(%[[control]]) wraps "tf.B"()
    tf_executor.island wraps "tf.B"() {_parallel_execution_ids = "r1:1"} : () -> ()
    // CHECK-NEXT: %[[control_3:.*]] = tf_executor.island(%[[control_2]]) wraps "tf.C"()

  %0:2 = tf_executor.graph {
    %control = tf_executor.island() wraps "tf.TPUReplicateMetadata"() {_tpu_replicate = "cluster", device = "/device:TPU:0", num_replicas = 2, topology = "topology"} : () -> ()
    %ri, %c0 = tf_executor.island wraps "tf.TPUReplicatedInput"(%arg0, %arg1) {index = 1 : i64, is_mirrored_variable = false, is_packed = false} : (tensor<i32>, tensor<i32>) -> tensor<i32>

    }
    tf_executor.fetch %island#0, %island#1, %island#2 : tensor<i32>, !tf_res, !tf_res
  }
  func.return %graph#0, %graph#1, %graph#2: tensor<i32>, !tf_res, !tf_res
}

// CHECK-LABEL: func @whileregion_cond
func.func @whileregion_cond(%arg0: tensor<i32>, %arg1: !tf_res, %arg2: !tf_res) -> tensor<i1> {
  %graph = tf_executor.graph {
    // CHECK: tf_executor.island
    %island:2 = tf_executor.island {