def LegalizeSparseToDense : Pat<
  (TF_SparseToDenseOp $sparse_indices, $output_shape, $sparse_values,
    $default_value, $validate_indices),
  (TFL_SparseToDenseOp $sparse_indices, $output_shape, $sparse_values,
    $default_value)>;

def LegalizeUnique : Pat<(TF_UniqueOp $arg0),(TFL_UniqueOp $arg0)>;

  %4 = "tf.Case"(%2, %arg0, %arg1) {branches = [@sub, @add], output_shapes = [#tf_type.shape<>], device = "noodle", is_stateless = false} : (tensor<i32>, tensor<f32>, tensor<f32>) -> tensor<f32>
  // CHECK: PartitionedCall
  // CHECK-SAME: f = @sub
  // CHECK-SAME: _cluster_launch = "not_ready"
  // CHECK-SAME: device = "noodle"

      CompileTimeConstantOperand<TF::SegmentSumV2Op, 2>,   // $num_segments
      CompileTimeConstantOperand<TF::SliceOp, 1, 2>,       // $begin, $size
      CompileTimeConstantOperand<TF::SparseToDenseOp, 1>,  // $output_shape
      CompileTimeConstantOperand<TF::SplitOp, 0>,          // $split_dim
      // $size_splits, $split_dim
      CompileTimeConstantOperand<TF::SplitVOp, 1, 2>,

  let summary = "A container for an iterator resource.";

  let arguments = (ins
    ConfinedAttr<TypeArrayAttr, [ArrayMinCount<1>]>:$output_types,
    ConfinedAttr<TF_ShapeAttrArray, [ArrayMinCount<1>]>:$output_shapes
  );

  let results = (outs
    Res<TF_ResourceTensor, [{A handle to the iterator that can be passed to a "MakeIterator" or
"IteratorGetNext" op. In contrast to Iterator, AnonymousIterator prevents

  Value none = rewriter.create<TFL::NoValueOp>(
      op->getLoc(), rewriter.getNoneType(), rewriter.getUnitAttr());

  Value output_shape =
      CreateCastToInt32(tf_op.getInputSizes(), op->getLoc(), rewriter);

  rewriter.replaceOpWithNewOp<TFL::Conv3DTransposeOp>(
      op, tf_op.getType(), output_shape, tf_op.getFilter(),
      tf_op.getOutBackprop(),
      /*bias=*/none, dilation_depth_factor, dilation_height_factor,

                .getScale(),
            /*filter_scales=*/filter_quantized_type.getScales());
        const ArrayRef<int64_t> output_shape =
            op->getResult(0).getType().cast<TensorType>().getShape();
        const SmallVector<int64_t, 1> bias_shape = {
            output_shape[output_shape.size() - 1]};
        // `tfl.fully_connected`'s `GetChannelDimIndex` is 0.
        const auto bias_quantized_type =

    "tf.Yield"(%1) : (tensor<5xf32>) -> ()
  }) {device = "/job:tpu_host_worker/replica:0/task:0/device:CPU:0", metadata = "", operandSegmentSizes = array<i32: 1, 2, 1>, output_shapes = [#tf_type.shape<>], output_types = [!tf_type.string]} : (tensor<4xf32>, tensor<3xf32>, tensor<!tf_type.resource>, tensor<2xf32>) -> tensor<!tf_type.variant>
  return
}

// -----

    // Shape of the final output. (Except for dimension folding in the
    // single diagonal case.)
    Shape output_shape;
    for (int i = 0; i < num_dims - 2; i++) {
      output_shape.push_back(input_type.getDimSize(i));
    }
    output_shape.push_back(num_diags);
    output_shape.push_back(max_diag_len);

    // A slice is the shape of what GatherOp copies per lookup. So the last

      %arg1: tensor<i64>
    ) {
      %1 = "tf.ReduceDataset"(%arg0, %arg1) {
        Targuments = [],
        Tstate = [i64], device = "",
        f = @__reduce_func_1, f._tf_data_function = true,
        output_shapes = [#tf_type.shape<>],
        output_types = [i64], use_inter_op_parallelism = true, _xla_compile_device_type="TPU"} :
          (tensor<!tf_type.variant>, tensor<i64>) -> (tensor<i64>)
      func.return
    }
    ```

  // CHECK-DAG: [[OUTPUT_SHAPE:%.+]] = "tf.ConcatV2"([[OUTPUT_BATCH]], [[OUTER_SHAPE_0]], [[OUTER_SHAPE_1]], [[PADDED_SHAPE_SPLITS]]#3, [[ZERO_I64]])
  // CHECK-DAG: [[RESHAPED:%.+]] = "tf.Reshape"([[PADDED]], [[RESHAPED_SHAPE]])
  // CHECK-DAG: [[PERMUTED:%.+]] = "tf.Transpose"([[RESHAPED]], [[PERMUTATION]])
  // CHECK-DAG: [[RESULT:%.+]] = "tf.Reshape"([[PERMUTED]], [[OUTPUT_SHAPE]])
  // CHECK-DAG: return [[RESULT]]