//   r0, r1, ..., rN = func.call @foo(arg0, arg1, ..., argN)
  //   "tf.yield"(r0, r1, ..., rN)
  if (!region.hasOneBlock()) return std::nullopt;
  Block& block = region.front();
  if (std::distance(block.begin(), block.end()) != 2) return std::nullopt;
  TF::YieldOp yield =
      llvm::dyn_cast_or_null<TF::YieldOp>(block.getTerminator());
  if (!yield) return std::nullopt;

      moveBlock(&tf_then_or_else_region.front(),
                &scf_then_or_else_region.front(), TypeRange(), rewriter);

      // Replace the current terminator (a `tf.Yield` op) with an `scf.yield`
      // op. The input of the `scf.yield` op is a list of results of `tf.Cast`
      // ops, each of which casts an operand of the current terminator to the
      // corresponding result type of the `tf.IfRegion` op.

			kv.SetIterKey(iter)
			seenk ^= kv.Uint()
			kv.SetIterValue(iter)
			seenv ^= kv.Uint()
		}
		if seenk != 0b111 {
			t.Errorf("iteration yielded keys %b, want %b", seenk, 0b111)
		}
		if seenv != 0b1110 {
			t.Errorf("iteration yielded values %b, want %b", seenv, 0b1110)
		}
	}

	// Reset should not allocate.
	n := int(testing.AllocsPerRun(10, func() {
		iter.Reset(ValueOf(m2))

    outlined_func.setNested();

    // We will "steal" the body of the island and replace it with a call to the
    // new function later.
    {
      YieldOp yield_op = island_op.GetYield();
      outlined_func.getBody().takeBody(island_op.getBody());

      // Replace the yield with a return
      OpBuilder replacer(yield_op);
      island_op.getBody().push_back(new Block);
      replacer.create<mlir::func::ReturnOp>(yield_op.getLoc(),

// to functions).
bool IsAlreadyOutlined(WhileOp while_op) {
  auto just_call = [](Region& region) {
    auto it = region.front().begin();
    if (!isa<func::CallOp>(*it)) return false;
    ++it;
    if (!isa<YieldOp>(*it)) return false;
    return true;
  };
  return just_call(while_op.getBody()) && just_call(while_op.getCond());
}

bool IsCompatibleTypeWithTFLCastOp(Type type) {
  auto elemType = getElementTypeOrSelf(type);

	if verbose {
		println("did", "%[3]s", "%[4]s", len(all))
	}
}
`

var mainCode = `

func main() {
	if verbose {
		println("main")
	}
	%s
}

func yield2(yield func(int)bool) { _ = yield(1) && yield(2) }
var slice2 = []int{1,2}

type output struct {
	ret int
	trace []any
}

func (o *output) log(x any) {
	o.trace = append(o.trace, x)
}

      island.getBody().front().begin(), body.getOperations(),
      copy_range.begin(), copy_range.end());
  builder.setInsertionPointToEnd(&island.getBody().front());
  builder.create<tf_executor::YieldOp>(loc, return_op.getOperands());
  for (auto item : llvm::enumerate(graph_op.getResults())) {
    return_op.setOperand(item.index(), item.value());
  }
}

std::unique_ptr<OperationPass<func::FuncOp>>

  llvm::SmallVector<Value, 8> replica_inputs(island_op.getControlInputs());

  // Replace replicate terminator with YieldOp.
  builder.setInsertionPoint(&terminator);
  builder.create<tf_executor::YieldOp>(terminator.getLoc(),
                                       terminator.getOperands());
  terminator.erase();

  builder.setInsertionPoint(island_op);
  IRMapping mapping;

 *       byte sequences under the covers.
 *   <li><b>hash code:</b> each hash function always yields hash codes of the same fixed bit length
 *       (given by {@link #bits}). For example, {@link Hashing#sha1} produces a 160-bit number,
 *       while {@link Hashing#murmur3_32()} yields only 32 bits. Because a {@code long} value is
 *       clearly insufficient to hold all hash code values, this API represents a hash code as an

 *       byte sequences under the covers.
 *   <li><b>hash code:</b> each hash function always yields hash codes of the same fixed bit length
 *       (given by {@link #bits}). For example, {@link Hashing#sha1} produces a 160-bit number,
 *       while {@link Hashing#murmur3_32()} yields only 32 bits. Because a {@code long} value is
 *       clearly insufficient to hold all hash code values, this API represents a hash code as an