if (failed(MatchReduceToArgMinMaxType1(reduce_op, is_float, is_argmax)) &&
        failed(MatchReduceToArgMinMaxType2(reduce_op, is_argmax)))
      return rewriter.notifyMatchFailure(
          reduce_op, "Unsupported Reduce -> ArgMax/ArgMin pattern");

    Value operand = reduce_op.getInputs().front();
    int64_t axis = reduce_op.getDimensions().getValues<int64_t>()[0];

      needs_transpose = true;
    }
    lhs_transpose.push_back(out_lhs_map[i]);
  }

  if (!needs_reduce_sum && !needs_transpose) {
    return rewriter.notifyMatchFailure(
        op, "unary einsum equation does not require transpose");
  } else if (needs_reduce_sum && !needs_transpose) {
    rewriter.replaceOp(op, lhs);
    return success();
  }

    // If index_vector_dim isn't the last dimension in indices then it isn't
    // supported yet.
    // TODO(tberghammer): Transpose indices to support this usecase.
    return rewriter.notifyMatchFailure(
        parent_op,
        "index vector dim isn't the last dimension in start indices");
  }
  return success();
}

// Check if the specified region is a binary reduction function that takes 2

      //
      if (scatter_dims_to_operand_dims != inserted_window_dims) {
        // Support only dimension numbers generated by numpy-like slice
        // operations.
        return rewriter.notifyMatchFailure(
            scatter_op, "unsupported scatter_dims_to_operand_dims");
      }

      // Transpose the operand and so that the trailing dimensions of the

          "integer or 16-bit/32-bit/64-bit float type during TF Lite "
          "transformation pass";
      return allow_tensorlist_pass_through_
                 ? rewriter.notifyMatchFailure(op, error_info)
                 : op.emitOpError(error_info);
    }

    Value element_shape = adaptor.getOperands()[0];
    Type shape_dtype = getElementTypeOrSelf(element_shape.getType());

            "than 'public'";
        if (main_func_op) {
          main_func_op->emitError(error_msg);
        }
        return rewriter.notifyMatchFailure(op, error_msg);
      }
    }
    Builder stablehlo_builder(stablehlo_module_op.get().getContext());
    // Rename XlaCallModuleOp's functions to avoid naming conflicts.

  // Skip int8 x int8 => int32.
  if (lhs_type.getElementType().isInteger(8) &&
      rhs_type.getElementType().isInteger(8)) {
    return rewriter.notifyMatchFailure(op,
                                       "skip unrolling for int8 BatchMatMulV3");
  }

  auto element_type = lhs_type.getElementType();

  if (element_type != rhs_type.getElementType()) {

    if (!IsIllegalType(op.getOutput().getType())) return failure();
    TF::TensorProtoAttr tensor_proto_attr;
    if (!matchPattern(op.getOperation(), m_Constant(&tensor_proto_attr))) {
      return rewriter.notifyMatchFailure(op, "operand must be constant.");
    }
    auto dense_attr_or = GetDenseAttrFromTensorProtoAttr(
        tensor_proto_attr.getValue(),
        mlir::dyn_cast<TensorType>(ToLegalType(op.getOutput().getType())));

      return rewriter.notifyMatchFailure(
          loc, "No Reshape->BroadcastTo->Reshape pattern found");
    }

    // Pattern is applied only if the broadcast_to shape has more than 5
    // dimensions.
    if (mlir::cast<ShapedType>(tfl_broadcast_to_op.getShape().getType())
            .getNumElements() < 6) {
      return rewriter.notifyMatchFailure(loc,

    if (!input_type) {
      return rewriter.notifyMatchFailure(op, "requires ranked input shape");
    }
    llvm::SmallVector<int64_t, 4> broadcast_dimensions;
    if (input_type.getRank() > 0) {
      auto ranked_output_type = mlir::dyn_cast<RankedTensorType>(output_type);
      if (!ranked_output_type) {
        return rewriter.notifyMatchFailure(op, "requires ranked output shape");
      }