return func;
  func::FuncOp cloned = func.clone();
  cloned.setPrivate();
  cloned.setName(
      StringAttr::get(func.getContext(), func.getName().str() + "_lifted"));
  SymbolTable(module).insert(cloned);
  return cloned;
}

// Eliminates unused results for If/Case operations. Also patches up the
// branch functions to (a) drop the ununsed return values, and (b) as a result

    return
  }

// Check that HashTable op in the initilizer is not lifted.
// CHECK: func.func @init_all_tables()
// CHECK: %[[OUT_0:.*]] = "tf.HashTableV2"()
// CHECK: "tf.LookupTableImportV2"(%[[OUT_0]]

	var s uint
	_ = 1.0 /* ERROR "shifted operand 1.0 (type float64) must be integer" */ <<s == 1
	_ = 1.0 /* ERROR "shifted operand 1.0 (type float64) must be integer" */ <<s == 1.0
	_ = 1 /* ERROR "shifted operand 1 (type float64) must be integer" */ <<s == 1.0
	_ = 1 /* ERROR "shifted operand 1 (type float64) must be integer" */ <<s + 1.0 == 1
	_ = 1 /* ERROR "shifted operand 1 (type float64) must be integer" */ <<s + 1.1 == 1

        outputContains "Listed [3, 2, 1] for org:testA"
        outputContains "Supplying metadata for module org:testA:3"
        outputContains "Supplying metadata for module org:testA:2"
        outputContains "Supplying metadata for module org:testA:1"
        outputContains "Listing versions for module testB"
        outputContains "Listed [2, 1] for org:testB"

  // here will be quantized with best effort.
  map<int32, QuantizedType> input_quantized_types = 1;
}

// Represents a matching method that matches quantizable units by lifted
// functions' names.
message FunctionNameMatcherSpec {
  // Regular expression to match lifted functions' names. Underlying regex
  // engine uses re2, which accepts a subset of PCRE. See
  // https://github.com/google/re2/wiki/Syntax for details.
  string regex = 1;

            'org:testA:3' {
                expectResolve()
            }
        }

        then:
        succeeds 'checkDeps'
    }

    void "falls back to repository listing when no version is listed"() {
        withLister([:])
        given:
        repository {
            'org:testA:1'()
            'org:testA:2'()
            'org:testA:3'()
        }
        buildFile << """

        for (ResourcePattern pattern : filteredPatterns) {
            visit(pattern, versionListPatterns, collector, result);
        }
        if (!collector.isEmpty()) {
            result.listed(collector);
        }
    }

    private List<ResourcePattern> filterDuplicates(List<ResourcePattern> patterns) {
        if (patterns.size() <= 1) {
            return patterns;
        }

		be those functions exported using a cgo //export comment.
		Requires exactly one main package to be listed.

	-buildmode=default
		Listed main packages are built into executables and listed
		non-main packages are built into .a files (the default
		behavior).

	-buildmode=shared
		Combine all the listed non-main packages into a single shared
		library that will be used when building with the -linkshared

      mlir::tf_executor::CreateTFExecutorGraphPruningPass(ops_to_preserve));
  // It is assumed at this stage there are no V1 control flow ops as Graph
  // functionalization is ran before import. Ops can be lifted out of
  // tf_executor dialect islands/graphs.
  pm.addNestedPass<FuncOp>(
      mlir::CreateExecutorDialectToFunctionalConversionPass());
  // Guarantee all functions have one use, which enables more exact shape

           "invariants. In the case of this pass, that means manually propagating "
           "controls to lifted parallel execute regions to the graph fetch to "
           "ensure the ops execute, as well as determining whether or not the "
           "islands created by this pass should be split after the replicated "
           "ops have been lifted.">
  ];

  let constructor = "TFDevice::CreateLaunchToDeviceAttributePass()";
}