getType(Project.class),
            getType("Lorg/gradle/api/internal/project/ProjectInternal;"),
            getType(Gradle.class),
            getType("Lorg/gradle/api/internal/GradleInternal;")
        );
        private static final Type JAVA_LANG_REFLECT_TYPE = getType(java.lang.reflect.Type.class);
        private static final Type OBJECT_TYPE = getType(Object.class);

    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");
    }

    if (!IsLastDimEqualToNumElements(inner_reshape_input.getType(),

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

  // Expect 1d lookup tensor and a non-scalar input.
  if (lookup_attr.getType().getRank() != 1 ||
      value_attr.getType().getRank() == 0) {
    return {};
  }

  int64_t outer_dim_size = value_attr.getType().getShape()[0];

        if (body_arg.getType() == while_operand.getType())
          body_arg.replaceAllUsesWith(while_operand);
        if (cond_arg.getType() == while_operand.getType())
          cond_arg.replaceAllUsesWith(while_operand);

        auto result = while_op.getResult(op_idx);
        if (result.getType() == while_operand.getType())
          result.replaceAllUsesWith(while_operand);
      }

    if (!mlir::cast<ShapedType>(conv_op.getRhs().getType()).hasStaticShape()) {
      return false;
    }
    if (!mlir::cast<ShapedType>(conv_op.getLhs().getType()).hasStaticShape() &&
        !mlir::cast<ShapedType>(conv_op.getType()).hasStaticShape()) {
      auto dnums = conv_op.getDimensionNumbers();
      auto lhs_type = mlir::cast<ShapedType>(conv_op.getLhs().getType());

  LogicalResult match(stablehlo::SelectOp op) const override {
    if (!IsQuantizedTensorType(op.getOperand(1).getType())) {
      return failure();
    }
    if (!IsQuantizedTensorType(op.getOperand(2).getType())) {
      return failure();
    }
    if (!IsQuantizedTensorType(op.getResult().getType())) {
      return failure();
    }
    return success();
  }

    const size_t idx = shape_offset_idx.index();

    if (failed(verifyCompatibleShape(shape.getType(), offset.getType())))
      return op.emitOpError() << "requires operand and result " << idx
                              << " to have compatible shapes";

    auto ranked_shape = mlir::dyn_cast<RankedTensorType>(shape.getType());
    if (!ranked_shape) continue;

    if (ranked_shape.getRank() != 1)

    return mlir::cast<TensorType>(input_tensor.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(kernel_tensor.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(window_strides.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(padding.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(lhs_dilation.getType()).hasStaticShape() &&

      Or<[TFL_OperandIsUnrankedPred<0>,
          CPred<"$_op.getOperand(0).getType().cast<ShapedType>().getRank() <= 1">,
          CPred<"$_op.getOperand(0).getType().cast<ShapedType>().getRank() == 2 && !$_op.getOperand(0).getType().cast<ShapedType>().hasStaticShape()">,
          CPred<"$_op.getOperand(0).getType().cast<ShapedType>().getRank() == 2 && $_op.getOperand(0).getType().cast<ShapedType>().getShape()[1] <= 4">]>>]> {

    /**
     * Returned by {@link #getType()} if the resource this <tt>SmbFile</tt>
     * represents is a server.
     */
    public static final int TYPE_SERVER = 0x04;
    /**
     * Returned by {@link #getType()} if the resource this <tt>SmbFile</tt>
     * represents is a share.
     */
    public static final int TYPE_SHARE = 0x08;
    /**
     * Returned by {@link #getType()} if the resource this <tt>SmbFile</tt>