bool MatchIotaBroadCastInDim(DenseIntElementsAttr dimensions, Value iota) {
  auto iota_broadcast =
      dyn_cast_or_null<mhlo::BroadcastInDimOp>(iota.getDefiningOp());
  if (!iota_broadcast || iota_broadcast.getBroadcastDimensions() != dimensions)
    return false;
  if (!isa_and_nonnull<mhlo::IotaOp>(
          iota_broadcast.getOperand().getDefiningOp()))
    return false;
  return true;
}

    broadcast_dims =
        !isa<mhlo::ConstantOp>(bcast_or_const_op) && !is_dynamic_broadcast
            ? dyn_cast_or_null<mhlo::BroadcastInDimOp>(bcast_or_const_op)
                  .getBroadcastDimensions()
            : nullptr;
    if (broadcast_dims == nullptr) {
      const auto filter_rank = filter_value.getShapedType().getRank();
      auto dimsType = RankedTensorType::get({1}, rewriter.getIntegerType(64));

      return rewriter.notifyMatchFailure(binary_op,
                                         "Result type must have static shape.");

    auto bcast_dims = bcast_op.getBroadcastDimensions();
    auto elem_type = const_val.getElementType();
    Attribute result;
    if (mlir::isa<FloatType>(elem_type)) {
      result = ConstFoldBroadcastInDim<FloatAttr>(result_type, const_val,

                          PatternRewriter& rewriter) const {
    SmallVector<int64_t> sorted_dims =
        llvm::to_vector(op.getBroadcastDimensions());
    llvm::sort(sorted_dims);
    auto broadcast_dims = op.getBroadcastDimensions();
    SmallVector<int32_t> permutation(
        llvm::map_range(broadcast_dims, [sorted_dims](int64_t dim) {

        auto broadcast_dimensions = builder_.CreateVector(
            mlir::GetVector<int64_t>(mlir::cast<mlir::vhlo::TensorV1Attr>(
                                         vhlo_op.getBroadcastDimensions()),
                                     vhlo_type_converter));

        auto broadcast_option = tflite::CreateStablehloBroadcastInDimOptions(
            builder_, broadcast_dimensions);