auto op_func_attrs = op.getOpFuncAttrs();
  if (!op_func_attrs.empty()) {
    auto print_key_value = [&](mlir::Attribute attr) {
      auto key_value = mlir::cast<mlir::ArrayAttr>(attr).getValue();
      auto key = key_value[0];
      auto value = key_value[1];

      p << mlir::cast<mlir::StringAttr>(key).getValue();
      p << " = ";
      p << value;
    };

    auto op_func_attr_array = op_func_attrs.getValue();
    p << " {";

        @Override
        public THIS value(@Nullable T value) {
            super.value(value);
            return Cast.uncheckedNonnullCast(this);
        }

        @Override
        public THIS value(Provider<? extends T> provider) {
            super.value(provider);
            return Cast.uncheckedNonnullCast(this);
        }

        @Override
        public void set(@Nullable File file) {

    // This is the argument used to refer to the pass in
    // the textual format (on the commandline for example).
    return "quant-replace-cast-hacks-with-tf-xla-ops";
  }
  StringRef getDescription() const final {
    // This is a brief description of the pass.
    return "Replace mixed-type Conv and Matmul cast hacks with TF XLA ops.";
  }

  void runOnOperation() override;
};

// Generates params for the XLA Convolution op.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.extensions.stdlib

import org.gradle.internal.Cast


fun <T> Any.uncheckedCast(): T =

     *   }
     * ```
     * Note that only nullability from "stable" smart cast types is considered. The
     * [spec](https://kotlinlang.org/spec/type-inference.html#smart-cast-sink-stability) provides an explanation on smart cast stability.
     */
    public fun KtExpression.isDefinitelyNull(): Boolean =

namespace mlir {
namespace quant {

UnrankedTensorType CreateUnknownShapeFromElementType(Type tensor_type) {
  if (!mlir::cast<TensorType>(tensor_type)) return UnrankedTensorType();
  return UnrankedTensorType::get(
      mlir::cast<TensorType>(tensor_type).getElementType());
}

}  // namespace quant

		),
	}
	c.syncHandler = c.handleVersionUpdate

	crdinformer.Informer().AddEventHandler(cache.ResourceEventHandlerFuncs{
		AddFunc: func(obj interface{}) {
			cast := obj.(*apiextensionsv1.CustomResourceDefinition)
			c.enqueueCRD(cast)
		},
		UpdateFunc: func(oldObj, newObj interface{}) {
			// Enqueue both old and new object to make sure we remove and add appropriate API services.

  }
}

LogicalResult SpaceToBatchNDOp::verify() {
  SpaceToBatchNDOp op = *this;
  const auto input_type = op.getInput().getType().cast<TensorType>();
  const auto block_shape_type = op.getBlockShape().getType().cast<TensorType>();
  const auto paddings_type = op.getPaddings().getType().cast<TensorType>();

  // Check that block_shape has rank 1.
  if (!IsOfRankOrUnranked(op.getBlockShape(), 1)) {

        ClassImplementationSnapshot currentImplementation = Cast.uncheckedNonnullCast(thisExecution.getImplementation());
        ClassImplementationSnapshot previousImplementation = Cast.uncheckedNonnullCast(lastExecution.getImplementation());
        ImmutableList<ImplementationSnapshot> currentAdditionalImplementations = Cast.uncheckedNonnullCast(thisExecution.getAdditionalImplementations());

 */
package org.gradle.api.internal.attributes;

import org.gradle.api.attributes.Attribute;
import org.gradle.api.attributes.Usage;
import org.gradle.api.internal.model.NamedObjectInstantiator;
import org.gradle.internal.Cast;
import org.gradle.internal.isolation.Isolatable;
import org.gradle.internal.isolation.IsolatableFactory;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;