ldr.SetSymSect(ldr.LookupOrCreateSym("runtime.noptrbss", 0), sect)
	ldr.SetSymSect(ldr.LookupOrCreateSym("runtime.enoptrbss", 0), sect)

	// Code coverage counters are assigned to the .noptrbss section.
	// We assign them in a separate pass so that they stay aggregated
	// together in a single blob (coverage runtime depends on this).
	covCounterDataStartOff = sect.Length

			//
			// If/when this happens, take note of the following:
			//
			// We must clear the destination before calling assignTo,
			// in case assignTo writes (with memory barriers) to the
			// target location used as scratch space. See issue 39541.
			v = v.assignTo("reflect.MakeFunc", typ, nil)
		stepsLoop:
			for _, st := range abid.ret.stepsForValue(i) {
				switch st.kind {
				case abiStepStack:

  let options = [
    Option<"default_device_", "default-device", "std::string", /*default=*/"\"cpu\"",
           "The default device to assign.">
  ];
  let description = [{
    Assigns the default device to all ops that have an empty (or
    nonexistent) device attribute.

    For example, if we have the code

    ```mlir

<p>
In assignments, each value must be <a href="#Assignability">assignable</a>
to the type of the operand to which it is assigned, with the following special cases:
</p>

<ol>
<li>
	Any typed value may be assigned to the blank identifier.
</li>

<li>
	If an untyped constant
	is assigned to a variable of interface type or the blank identifier,

      llvm::append_range(worklist, use->getUsers());
      continue;
    }

    TF::AssignVariableOp assign_op = llvm::dyn_cast<TF::AssignVariableOp>(use);
    if (!assign_op) {
      continue;
    }
    auto subtypes = mlir::cast<TF::ResourceType>(
                        getElementTypeOrSelf(assign_op.getResource()))
                        .getSubtypes();
    if (subtypes.empty()) {
      continue;
    }

  if (GetReshapeOutputType(input, shape, error_handler, output_type)
          .succeeded()) {
    inferredReturnTypes.assign({output_type});
    return success();
  }
  Type result_type;
  result_type = UnrankedTensorType::get(
      input.getType().cast<ShapedType>().getElementType());
  inferredReturnTypes.assign({result_type});
  return success();
}

        } else {
            // TODO - the suffix should be a deterministic function of the known and enabled annotations
            // For now, just assign using a counter
            suffix = ClassGeneratorSuffixRegistry.assign("$Decorated");
            generatedClasses = cacheFactory.newClassMap();
        }

The filter name to match on. type: string subFilter: description: The next level filter within this filter to match upon. properties: name: description: The filter name to match on. type: string type: object type: object name: description: The name assigned to the filter chain. type: string sni: description: The SNI value used by a filter chain's match condition. type: string transportProtocol: description: Applies only to `SIDECAR_INBOUND` context. type: string type: object listenerFilter: description:...

template <class Op>
static LogicalResult InferenceFoldOperandsPermutation(
    ArrayRef<int64_t> permutation, Op* op) {
  // FusedBatchNorm in training mode is a layout sentitive operation, and should
  // have already assigned an optimal data format.
  if (op->getIsTraining()) return failure();
  return ::mlir::TF::FoldOperandsPermutation(permutation, op);
}

template <class Op>

      "dev": true,
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/object.assign": {
      "version": "4.1.4",
      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz",
      "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==",
      "dev": true,