extraPages := physPageSize / pageSize

		// Find a big enough region first, but then only allocate the
		// aligned portion. We can't just allocate and then free the
		// edges because we need to account for scavenged memory, and
		// that's difficult with alloc.
		//
		// Note that we skip updates to searchAddr here. It's OK if
		// it's stale and higher than normal; it'll operate correctly,

  let constructor = "TFTPU::CreateTPUColocateSplitsPass()";
  let description = [{
    It is beneficial for performance to assign a `Split` op to the same device
    as its predecessor. This is because the weight of cut edges is always
    minimized when the `Split` is with its predecessor. This colocation
    constraint will be used by the placer graph optimization to assign a device
    to the op.

- [`KT-58191`](https://youtrack.jetbrains.com/issue/KT-58191) K2: capturing closures successors that are already resolved (thanks to backward edges) must be taken into account for allowing smart casts
- [`KT-67144`](https://youtrack.jetbrains.com/issue/KT-67144) K2: potential NPE when assigning to unstable vars

  invocationBounds.emplace_back(InvocationBounds::getUnknown());
}

bool WhileRegionOp::areTypesCompatible(Type t1, Type t2) {
  // For now, we don't enforce type checking across control-flow edges.
  return true;
}

//===----------------------------------------------------------------------===//
// WhileRegionOp canonicalization

Class <org.gradle.execution.plan.edges.ComplexDependencyNodesSet> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ComplexDependencyNodesSet.java:0)
Class <org.gradle.execution.plan.edges.ComplexDependentNodesSet> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ComplexDependentNodesSet.java:0)

    [HasParent<"mlir::func::FuncOp">, RecursiveMemoryEffects, SingleBlockImplicitTerminator<"YieldOp">]> {
  let summary = [{
    The `TFL.control_node` operation wraps single-block operations in order to attach control edges.
  }];

  let description = [{
    This is used to wrap regions and attach control dependencies to them. Typically,
    this will happen in one of the last steps before emitting the flatbuffer model

                  (GTSM) which protects against spoofed packets by ignoring received
                  packets with a smaller than expected TTL value. The provided value
                  is the number of hops (edges) between the peers.
                type: integer
            type: object
        type: object
    served: true
    storage: true
status:
  acceptedNames:
    kind: ""
    plural: ""

qw=Gt(),G_=ke(),Wl=class extends G_{replace(e,t){return t==="-webkit-"?e.replace(this.regexp(),"$1-webkit-optimize-contrast"):t==="-moz-"?e.replace(this.regexp(),"$1-moz-crisp-edges"):super.replace(e,t)}old(e){return e==="-webkit-"?new qw(this.name,"-webkit-optimize-contrast"):e==="-moz-"?new qw(this.name,"-moz-crisp-edges"):super.old(e)}};Wl.names=["pixelated"];Rw.exports=Wl});var Fw=v((SI,Bw)=>{l();var H_=ke(),Gl=class extends H_{replace(e,t){let r=super.replace(e,t);return t==="-webkit-"&&(r=...

  );

  TF_DerivedOperandTypeAttr T = TF_DerivedOperandTypeAttr<0>;
}

def TF_NoOp : TF_Op<"NoOp", [Pure]> {
  let summary = "Does nothing. Only useful as a placeholder for control edges.";

  let arguments = (ins);

  let results = (outs);
}

def TF_NonMaxSuppressionV3Op : TF_Op<"NonMaxSuppressionV3", [Pure]> {
  let summary = [{