// And extend the pettern to handle dynamic shapes.
    if (!inner_reshape_op.getOutput().getType().hasStaticShape() ||
        !tfl_broadcast_to_op.getOutput().getType().hasStaticShape() ||
        !outer_reshape_op.getOutput().getType().hasStaticShape()) {
      return rewriter.notifyMatchFailure(
          loc, "Unsupported shapes. Currely only static shapes are supported");

    return failure();
  }
};

// Return true if the given Add operation has the CPU kernel supported shapes.
bool VerifyAddOpShapeConstraints(AddOp op) {
  auto element_type = getElementTypeOrSelf(op.getOutput().getType());

  // Allows F32, QI8, QUI8 and I32 outputs when the operands have valid shapes,
  // which are broadcastable shapes up to four dimensions or have same shapes.

  LogicalResult match(stablehlo::ConstantOp op) const override {
    return success(IsQuantizedTensorType(op.getOutput().getType()));
  }

  void rewrite(stablehlo::ConstantOp op,
               PatternRewriter& rewriter) const override {
    rewriter.replaceOpWithNewOp<TFL::QConstOp>(
        op, /*qtype=*/TypeAttr::get(op.getOutput().getType()),
        /*value=*/op.getValue());
  }
};

  // scalar or a vector based on `shrink_axis_mask` because we have rejected
  // the case of `new_axis_mask` != 0.
  auto output_elt_ty =
      getOutput().getType().cast<ShapedType>().getElementType();
  auto output_ty = getOutput().getType().dyn_cast<RankedTensorType>();
  if (!output_ty || !output_ty.hasStaticShape()) {
    if (getShrinkAxisMask() == 1) {

                                        TypeRange body_result_types) {
  if (!op.getShapeInvariant())
    return RefineTypeForPassThroughOperands(op, op.getInput(), op.getOutput());

  bool changed = false;
  for (auto entry :
       zip(op.getInput().getTypes(), op.getOutput(), body_result_types)) {
    Value result = std::get<1>(entry);
    TensorType body_result_type = mlir::cast<TensorType>(std::get<2>(entry));

             << "found incompatible broadcast batch dimensions for lhs shape "
             << x_ty << " and rhs shape " << y_ty;
  }

  RankedTensorType output_ty = GetRankedTensorTypeForOperand(op.getOutput());
  if (!output_ty) return success();

  int64_t expected_output_rank = std::max(x_ty.getRank(), y_ty.getRank());
  if (output_ty.getRank() != expected_output_rank)
    return op.emitOpError()

  let extraClassDeclaration = [{
  // FixedOutputRangeInterface:
  quant::UniformQuantizedType GetFixedOutputRange(
      bool is_signed, int bit_width) {
    auto result_type = getOutput().getType();
    // central_value = min_value / 2 + (max_value - 1) / 2 + 1
    // zero_point = central_value
    // scale = 1. / (central_value - min_value)

public void setProperty(String, Object) throws IllegalArgumentExcep, IllegalStateExceptio; public Object getProperty(String) throws IllegalArgumentExcep; private String getLocation(); public java.io.Writer getWriter(); public void setOutput(java.io.Writer); public void setOutput(java.io.OutputStream, String) throws java.io.IOException; public void startDocument(String, Boolean) throws java.io.IOException; public void endDocument() throws java.io.IOException; public void setPrefix(String, String) throws...

Method <org.gradle.plugins.ide.eclipse.model.SourceFolder.getName()> does not have raw return type assignable to org.gradle.api.provider.Property in (SourceFolder.java:0)
Method <org.gradle.plugins.ide.eclipse.model.SourceFolder.getOutput()> does not have raw return type assignable to org.gradle.api.provider.Property in (SourceFolder.java:0)

}
func testTransportIgnores408(t *testing.T, mode testMode) {
	// Not parallel. Relies on mutating the log package's global Output.
	defer log.SetOutput(log.Writer())

	var logout strings.Builder
	log.SetOutput(&logout)

	const target = "backend:443"

	cst := newClientServerTest(t, mode, HandlerFunc(func(w ResponseWriter, r *Request) {
		nc, _, err := w.(Hijacker).Hijack()