// live_in[5] = use[5]   U (live_out[5] - def[5])
//            = {%3}     U ({∅} - {∅})            = {%3}
// live_in[4] = use[4]   U (live_out[4] - def[4])
//            = {%1, %2} U ({%3} - {%3})          = {%1, %2}
// live_in[3] = use[3]   U (live_out[3] - def[3])
//            = {%0, %1} U ({%1, %2} - {%2})      = {%0, %1}
// live_in[2] = use[2]   U (live_out[2] - def[2])

  return_builder.create<tf_device::ReturnOp>(return_builder.getUnknownLoc(),
                                             live_outs);

  llvm::SmallVector<Type, 4> live_out_types;
  live_out_types.reserve(live_outs.size());
  for (Value v : live_outs) {
    live_out_types.emplace_back(v.getType());
  }

  tf_device::LaunchOp launch_op = builder->create<tf_device::LaunchOp>(
      builder->getUnknownLoc(), builder->getStringAttr(c.target),

				}
			}

			if !be.liveout.Eq(newliveout) {
				change = true
				be.liveout.Copy(newliveout)
			}

			// A variable is live on input to this block
			// if it is used by this block, or live on output from this block and
			// not set by the code in this block.
			//
			// in[b] = uevar[b] \cup (out[b] \setminus varkill[b])
			newlivein.AndNot(be.liveout, be.varkill)
			be.livein.Or(newlivein, be.uevar)

  // CHECK: %[[SIZE:.*]] = "tf.Const"() <{value = dense<5> : tensor<i32>}> : () -> tensor<i32>
  %size_out = "tf.TensorArraySizeV3"(%ta#0, %write) : (tensor<!tf_type.resource>, tensor<f32>) -> tensor<i32>
  // CHECK: return %[[SIZE]] : tensor<i32>
  func.return %size_out : tensor<i32>
}

// -----

// Test inferring shape from the first scatter.

// CHECK-LABEL: func @main

	linesIn := strings.Split(f.Preamble, "\n")
	linesOut := make([]string, 0, len(linesIn))
	f.NoCallbacks = make(map[string]bool)
	f.NoEscapes = make(map[string]bool)
	for _, line := range linesIn {
		l := strings.TrimSpace(line)
		if len(l) < 5 || l[:4] != "#cgo" || !unicode.IsSpace(rune(l[4])) {
			linesOut = append(linesOut, line)
		} else {
			linesOut = append(linesOut, "")

			// #cgo (nocallback|noescape) <function name>