}
    button#navbar-toggle-button.expanded span.nav-bar-toggle-icon:nth-child(1) {
        transform: rotate(45deg);
        transform-origin: 10% 10%;
        width: 26px;
    }
    button#navbar-toggle-button.expanded span.nav-bar-toggle-icon:nth-child(2) {
        opacity: 0;
    }
    button#navbar-toggle-button.expanded span.nav-bar-toggle-icon:nth-child(3) {

    if (!fft_len_type) return failure();

    auto output_type =
        mlir::dyn_cast_or_null<RankedTensorType>(rfft_op.getResult().getType());
    if (!output_type) return failure();

    // Expanded inputs.
    // Insert at -2 location.
    auto one_ele_type =
        tensorflow::GetTypeFromTFTensorShape({1}, rewriter.getIntegerType(32));
    auto minus_two = CreateConstOpWithSingleValue(&rewriter, rfft_op.getLoc(),

        ArrayRef<Value>({slice1, expanded_item, slice2}));
    return success();
  }

  // This function rewrites the original op into a XLA DynamicUpdateSlice op.
  // |item| is expanded to have the same dimension as input_handle and
  // |index| is expanded to [index, 0, 0, ...] as the indices to input_handle.
  // On a high level, it's doing something like:
  // def : Pat<(TensorListSetItem($input_handle, $index, $item)),

		},
		// Basic zero IPv6 address.
		{
			in: "::",
			ip: MkAddr(Mk128(0, 0), Z6noz),
		},
		// Localhost IPv6.
		{
			in: "::1",
			ip: MkAddr(Mk128(0, 1), Z6noz),
		},
		// Fully expanded IPv6 address.
		{
			in: "fd7a:115c:a1e0:ab12:4843:cd96:626b:430b",
			ip: MkAddr(Mk128(0xfd7a115ca1e0ab12, 0x4843cd96626b430b), Z6noz),
		},
		// IPv6 with elided fields in the middle.
		{

		return f(root, dir)
	}

	// Try using paths we received.
	if rel, ok = hasSubdir(root, dir); ok {
		return
	}

	// Try expanding symlinks and comparing
	// expanded against unexpanded and
	// expanded against expanded.
	rootSym, _ := filepath.EvalSymlinks(root)
	dirSym, _ := filepath.EvalSymlinks(dir)

	if rel, ok = hasSubdir(rootSym, dir); ok {
		return
	}

        run 'copy'

        then:
        executedAndNotSkipped(':copy')
        file('dest/a.txt').text == "1 + 2"
    }

    def "useful help message when property cannot be expanded"() {
        given:
        buildFile << """
            task copy (type: Copy) {
                // two.a expects "one" to be defined
                from('src/two/two.a')
                into('dest')

// is a wildcard.
//
// The candidates for a given module path matching (or containing a package
// matching) a wildcard query depend only on the initial build list, but the set
// of modules may be expanded by other queries, so wildcard queries need to be
// re-evaluated whenever a potentially-matching module path is added to the
// build list.
func (r *resolver) performWildcardQueries(ctx context.Context) {

//
// r3 = r1 * r2
//    = s1 (q1 - z1) * s2 (q2 - z2)
//    = s1 s2 (q1 - z1) * (q2 - z2)
//
// Unlike `ComposeUniformQuantizedDotGeneralOp`, the pattern assumes that the
// term "(q1 - z1) * (q2 - z2)" is not expanded. This is done to reduce
// unnecessary op count. Also, the subtractions "(q - z)" are performed in i32
// to avoid underflows.
//
// In StableHLO text representation, the pattern is as the following

// loadFromRoots attempts to load the build graph needed to process a set of
// root packages and their dependencies.
//
// The set of root packages is returned by the params.listRoots function, and
// expanded to the full set of packages by tracing imports (and possibly tests)
// as needed.
func loadFromRoots(ctx context.Context, params loaderParams) *loader {
	ld := &loader{
		loaderParams: params,

	return t.extra.(*Chan)
}

type Tuple struct {
	first  *Type
	second *Type
	// Any tuple with a memory type must put that memory type second.
}

// Results are the output from calls that will be late-expanded.
type Results struct {
	Types []*Type // Last element is memory output from call.
}

// Array contains Type fields specific to array types.
type Array struct {
	Elem  *Type // element type