rewriter.replaceOpWithNewOp<TFL::QConstOp>(
        op, /*qtype=*/TypeAttr::get(op.getOutput().getType()),
        /*value=*/op.getValue());
  }
};

// Splits hybrid quantized `stablehlo.dot_general` into `tfl.dequantize` and
// float `stablehlo.dot_general` op. Legalization of float
// `stablehlo.dot_general` op relies on existing passes for conversion of
// StableHLO -> MHLO -> TF -> TFL.

    mlir::func::FuncOp float_func =
        dyn_cast<func::FuncOp>(symbol_table.lookup(f_attr.getValue()));
    rewriter.setInsertionPointAfter(float_func);

    // Applies only for hybrid ops in SRQ.
    const bool is_hybrid =
        ContainsFloatResultType(result_types) &&
        (quantization_method_ == tensorflow::quantization::QuantizationMethod::

* Copy annotations back from RS to Deployment on rollback ([#23160](https://github.com/kubernetes/kubernetes/pull/23160), [@janetkuo](https://github.com/janetkuo))
* Trusty: Support hybrid cluster with nodes on ContainerVM ([#23079](https://github.com/kubernetes/kubernetes/pull/23079), [@andyzheng0831](https://github.com/andyzheng0831))

      return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16};
    }
  }];
}

// UnidirectionalSequenceLstm op.
// TODO(ashwinm): Add constraint to validate the combination of operands
// that are valid for hybrid vs fully quantized vs float only semantics
def TFL_UnidirectionalSequenceLSTMOp :
  TFL_Op<"unidirectional_sequence_lstm",
          [LstmMandatoryInputsConstraint,
           LstmOptionalPeepholeWeightConstraint,

* Copy annotations back from RS to Deployment on rollback ([#23160](https://github.com/kubernetes/kubernetes/pull/23160), [@janetkuo](https://github.com/janetkuo))
* Trusty: Support hybrid cluster with nodes on ContainerVM ([#23079](https://github.com/kubernetes/kubernetes/pull/23079), [@andyzheng0831](https://github.com/andyzheng0831))

  auto lookup_attr = operands[0].dyn_cast_or_null<DenseIntElementsAttr>();
  auto value_attr = operands[1].dyn_cast_or_null<DenseElementsAttr>();
  if (!lookup_attr || !value_attr) {
    return {};
  }

  // Hybrid lookup is not supported.
  if (value_attr.getType().getElementType() != getType().getElementType()) {
    return {};
  }

  // Expect 1d lookup tensor and a non-scalar input.

- **Cluster Federation**
  - Global Multi-cluster HTTP(S) Ingress across GCE and GKE clusters.
  - Expanded support for federated hybrid-cloud resources including ReplicaSets, Secrets, Namespaces and Events.
- **Security**
  - Increased pod-level security granularity (eg: Container Image Policies, AppArmor and `sysctl` support)

  let hasVerifier = 1;
}

def TF_UniformQuantizedConvolutionHybridOp : TF_Op<"UniformQuantizedConvolutionHybrid", [Pure]> {
  let summary = [{
Perform hybrid quantized convolution of float Tensor `lhs` and quantized Tensor `rhs`.
  }];

  let description = [{
Given float `lhs` and quantized `rhs`, internally performs quantization on `lhs`,

    * The new support for ORM mode fixes issues/adds features related to ORMs with lazy-loading, hybrid properties, dynamic/getters (using `@property` decorators) and several other use cases.
    * This applies to ORMs like SQLAlchemy, Peewee, Tortoise ORM, GINO ORM and virtually any other.