SmallVector<int32_t> padding_values(2 * num_dims, 0);
  if (conv_padding.strref() == "EXPLICIT") {
    if (explicit_paddings.size() != 2 * num_dims) {
      emitError(loc,
                absl::StrFormat(
                    "explicit_paddings are expected to be %d-element arrays",
                    2 * num_dims));
      return {};
    }
    for (int i : spatial_dims) {

  RewritePatternSet patterns(ctx);
  func::FuncOp func = getOperation();

  patterns.add<AddCustomAggregationOp>(ctx, calib_opts_);
  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    func.emitError() << "quant-insert-custom-aggregation-ops failed.";
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>

  mlir::RewritePatternSet patterns(ctx);
  patterns.add<RewriteXlaHostComputeMlir>(ctx);
  if (failed(mlir::applyPatternsAndFoldGreedily(module, std::move(patterns)))) {
    return module.emitError("failed to apply tf export preparation patterns");
  }

  // TODO(hinsu): Investigate if the semantics of keys for these communication
  // ops between the old bridge and new bridge can be reconciled.

    // future work.
    patterns.add<TF::ConvertTFEinsumOp>(ctx);
  }

  if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
    func.emitError() << "quant-prepare-lifting failed.";
    signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>> CreatePrepareLiftingPass(
    const OpSet target_opset) {

  if (op.getNumSparse() != sparse_types_count) {
    return op.emitError() << "attribute 'num_sparse' should be the same as "
                          << "the length of attribute 'sparse_types'";
  }
  if (op.getSparseIndices().size() != sparse_types_count) {
    return op.emitError() << "output 'sparse_indices' should have same length "
                          << "as attribute 'sparse_types'";

  list<OpBuilder> builders = [
    OpBuilder<(ins "Value":$x, "Value":$y),
    [{
  auto resultType =
      OpTrait::util::getBroadcastedType(x.getType(), y.getType());
  if (!resultType) {
    mlir::emitError($_state.location, "non-broadcastable operands");
    resultType = $_builder.getNoneType();
  }
  return build($_builder, $_state, resultType, x, y);
}]>];
}

    auto dense_attr_or = GetDenseAttrFromTensorProtoAttr(
        tensor_proto_attr.getValue(),
        mlir::dyn_cast<TensorType>(ToLegalType(op.getOutput().getType())));
    if (failed(dense_attr_or)) {
      op->emitError("failed to get DenseElementAttr.");
      return failure();
    }

    rewriter.replaceOpWithNewOp<TF::ConstOp>(
        op, ToLegalType(op.getOutput().getType()), *dense_attr_or);
    return success();
  }

  int feature_group_cnt = 1;
  ShapedType input_shape =
      mlir::dyn_cast<ShapedType>(op->getOperand(0).getType());
  if (!input_shape) {
    return op->emitError(
        "Only input with known shape is supported for Uniform Quantized "
        "opset.");
  }

  if (op->getParentOfType<func::FuncOp>().getName().contains("depthwise_")) {

  if (failed(applyPassManagerCLOptions(pm))) {
    return tensorflow::errors::Aborted(
        "Failed to apply MLIR pass manager CL options.");
  }

  auto error_handler = [&](const Twine& msg) {
    emitError(UnknownLoc::get(pm.getContext())) << msg;
    return failure();
  };
  if (failed(pass_pipeline.addToPipeline(pm, error_handler))) {
    return tensorflow::errors::Aborted("Failed to add passes to pipeline.");
  }

  // Iterate over the sorted list of functions to keep the order deterministic.
  for (func::FuncOp func : GetSortedFunctions(module)) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError() << "quant-lift-quantizable-spots-as-functions failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateLiftQuantizableSpotsAsFunctionsPass(