if atEOF && len(data) == 0 {
		return 0, nil, nil
	}
	sep := len([]byte(yamlSeparator))
	if i := bytes.Index(data, []byte(yamlSeparator)); i >= 0 {
		// We have a potential document terminator
		i += sep
		after := data[i:]
		if len(after) == 0 {
			// we can't read any more characters
			if atEOF {
				return len(data), data[:len(data)-sep], nil
			}
			return 0, nil, nil
		}

	for i, c := range data {
		if err := b.WriteByte(c); err != nil {
			return i, err
		}
	}
	return len(data), nil
}

func (b blockWriter) close() {
	// Write the block terminator (0x00), either by itself, or along with a
	// pending sub-block.
	if b.e.buf[0] == 0 {
		b.e.writeByte(0)
	} else {
		n := uint(b.e.buf[0])
		b.e.buf[n+1] = 0
		b.e.write(b.e.buf[:n+2])
	}

      $_state.addTypes(result_types);
      $_state.addRegion();
    }]>
  ];

  let hasCanonicalizer = 1;
}

def TfDevice_ReturnOp : TfDevice_Op<"return", [Pure, ReturnLike, Terminator]> {
  let summary = [{
The `tf_device.return` operation terminates and returns values from a
`tf_device` dialect operation.
  }];

  let arguments = (ins
    Variadic<AnyType>:$results
  );

  let builders = [
    OpBuilder<(ins),

  let hasVerifier = 1;
  let hasCustomAssemblyFormat = 1;
}

def TFR_TFRReturnOp : TFR_Op<"return", [HasParent<"TFRFuncOp">, Pure,
                                        ReturnLike, Terminator]> {
  let description = [{
    A terminator operation for regions that appear in the body of  `tfr.func`
    functions. The operands to the `tfr.return` are the result values returned
    by an invocation of the `tfr.func`.

                                executor_graph.getBody().end());

    // Add terminator of tf_executor::graph
    rewriter.setInsertionPointToEnd(&executor_graph.getBody().front());
    rewriter.create<tf_executor::FetchOp>(loc);

    // Add terminator of func
    rewriter.setInsertionPointToEnd(&func.getBody().front());
    rewriter.create<func::ReturnOp>(loc);

    return success();
  }

 private:
  // Check if op's user or op's user after an identity op is connected to a
  // terminator.
  bool checkIfAnyUserIsConnectedToTermiantor(BlockArgument op) const {
    for (const auto& user : op.getUsers()) {
      if (user->template hasTrait<OpTrait::IsTerminator>()) return true;
      if (auto next_user = dyn_cast_or_null<TF::IdentityOp>(user)) {

func.func @graph_with_invalid_terminator(%arg0: tensor<*xf32>) -> tensor<*xf32> {
  tf_executor.graph {
// expected-error@-1 {{custom op 'tf_executor.graph' expects a tf_executor.fetch terminator}}
    func.return
  }
  func.return %arg0 : tensor<*xf32>
}

// -----

// Check that a tf_executor.fetch parent is a graph.
func.func @parent_is_graph() {
  "tf.some_op"() ({
    tf_executor.fetch

      if (isa<QuantizeOpT, DequantizeOpT>(candidate_op)) {
        return failure();
      }

      // If the op is terminator, we shouldn't rewrite.
      if (candidate_op->hasTrait<OpTrait::IsTerminator>()) {
        return failure();
      }

      if (!IsOpQuantizableStableHlo(candidate_op)) {
        return failure();
      }

    old_region_results[i].replaceAllUsesWith(new_parallel_execute_op->getResult(
        var_access_info.old_to_new_output_mapping[i] +
        num_results_before_region));
  }

  // Replace original terminator with new terminator for returning merged
  // execute results.
  Operation* old_terminator = execute_region->front().getTerminator();
  builder->setInsertionPointToEnd(&execute_region->front());

  let results = (outs Variadic<AnyType>:$outputs);
  let regions = (region SizedRegion<1>:$body);
  let hasVerifier = 1;
}

def Quantization_ReturnOp : Quantization_Op<"return", [Terminator]> {
  let summary = [{
    The `return` operation terminates a quantize region and returns values.
  }];

  let arguments = (ins Variadic<AnyTensor>:$results);
}