}
	out.NodeName = in.NodeName
	if in.Results != nil {
		in, out := &in.Results, &out.Results
		*out = make([]resource.DriverAllocationResult, len(*in))
		for i := range *in {
			if err := Convert_v1alpha2_DriverAllocationResult_To_resource_DriverAllocationResult(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Results = nil
	}
	return nil
}

}

def RemoveUnusedWhileResultsPass : Pass<"tf-remove-unused-while-results", "mlir::func::FuncOp"> {
  let summary = "Removes unused results from tf.WhileRegion ops";
   let description = [{
      Removes unused results from `tf.WhileRegion` ops along with the defining
      ops in the body, if it is safe to do so.
      Currently, the pass detects results with following properties:

// Code generated by gen/cmpConstGen.go. DO NOT EDIT.

package main

import (
	"reflect"
	"runtime"
	"testing"
)

// results show the expected result for the elements left of, equal to and right of the index.
type result struct{ l, e, r bool }

var (
	eq = result{l: false, e: true, r: false}
	ne = result{l: true, e: false, r: true}
	lt = result{l: true, e: false, r: false}
	le = result{l: true, e: true, r: false}

  func.return %0 : tensor<2xf32>
}

// -----

// tf.Region yield number of results should match op number of results
func.func @testIfRegionThenResultCount(%arg0: tensor<i1>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  // expected-error @+1 {{'tf.IfRegion' op  region control flow edge from Region #0 to parent results: source has 2 operands, but target successor needs 1}}
  %0 = "tf.IfRegion"(%arg0) ({

				t.Fatalf("%v: Expected %#v, got %#v", name, e, a)
			}
		})
	}
}

// TestStoreListResourceVersion tests that if List with ResourceVersion > 0, it will wait until
// the results are as fresh as given version.
func TestStoreListResourceVersion(t *testing.T) {
	fooPod := &example.Pod{
		ObjectMeta: metav1.ObjectMeta{Namespace: "test", Name: "foo"},
		Spec:       example.PodSpec{NodeName: "machine"},

                                       ResultRange results);

  // Makes result types match the operand types (the i-th result type will
  // match the i-th operand type). Returns true if anything is changed.
  bool RefineTypeForPassThroughOperands(Operation* op, OperandRange operands,
                                        ResultRange results);

  // Makes result type's shape match the corresponding operand's shape.

  std::vector<AssetFileDef> asset_file_defs;
  TF_RETURN_IF_ERROR(
      internal::GetAssetFileDefs(input_.meta_graph_def(), &asset_file_defs));

  std::vector<AssetInfo> results;
  results.reserve(asset_file_defs.size());

  mlir::OpBuilder builder(module_->getBodyRegion());
  unsigned i = 0;  // Use to generate unique sym_name(s) for duplicate assets.
  for (const auto& asset : asset_file_defs) {

	// and then copies the results back into scratch.
	call(methodFrameType, methodFn, methodFrame, uint32(methodFrameType.Size()), uint32(methodABI.retOffset), uint32(methodFrameSize), &methodRegs)

	// Copy return values.
	//
	// This is somewhat simpler because both ABIs have an identical
	// return value ABI (the types are identical). As a result, register

 * identical to the list returned by the parameterless <code>list()</code>
 * method minus filenames filtered by the specified filter.
 *
 * @param filter a filename filter to exclude filenames from the results
 * @throws SmbException
 # @return An array of filenames
 */
    public String[] list( SmbFilenameFilter filter ) throws SmbException {

// (see 'go help build') to force rebuilding of packages that
// depend on the updated C libraries.
//
// The go command also caches successful package test results.
// See 'go help test' for details. Running 'go clean -testcache' removes
// all cached test results (but not cached build results).
//
// The go command also caches values used in fuzzing with 'go test -fuzz',
// specifically, values that expanded code coverage when passed to a