Pat<(TF_MatrixSetDiagV2Op $input, $diagonal,
            (Arith_ConstantOp ConstantAttr<I32ElementsAttr, "{0}">)),
          (TF_MatrixSetDiagOp $input, $diagonal)>;

// `align` attribute can be ignored because we only support converting
// `MatrixSetDiagV3` to `MatrixSetDiag` with default `k` inputs.
def ConvertMatrixSetDiagV3ToMatrixSetDiag :
      Pat<(TF_MatrixSetDiagV3Op $input, $diagonal,

		var buf bytes.Buffer
		if err := Encode(&buf, src, nil); err != nil {
			t.Errorf("gray-diagonal: Encode: %v", err)
			return
		}
		m, err := Decode(&buf)
		if err != nil {
			t.Errorf("gray-diagonal: Decode: %v", err)
			return
		}
		if got, want := m.Bounds(), image.Rect(0, 0, 6, 6); got != want {
			t.Errorf("gray-diagonal: got %v, want %v", got, want)
			return
		}

  let summary = "Returns a diagonal tensor with a given diagonal values.";

  let description = [{
Given a `diagonal`, this operation returns a tensor with the `diagonal` and
everything else padded with zeros. The diagonal is computed as follows:

Assume `diagonal` has dimensions [D1,..., Dk], then the output is a tensor of

  (TFL_NonMaxSuppressionV5Op $boxes, $scores, $max_output_size, $iou_threshold,
    $score_threshold, $soft_nms_sigma)>;

def LegalizeMatrixDiag : Pat<(TF_MatrixDiagOp $diagonal),
                             (TFL_MatrixDiagOp $diagonal)>;

def LegalizeConv2DBackpropInput : Pat<
  (TF_Conv2DBackpropInputOp $input_sizes, $filter, $out_backprop,
     IsIntList1XY1:$strides,
     BoolAttr:$use_cudnn_on_gpu,

  // LSTM `func::FuncOps` with indy behavior always have the `tf.api_implements`
  // function attribute prefixed with `"indy_lstm_"`.
  // IndyLSTMs have diagonal recurrent weight matrices and can benefit from
  // more efficent operations in TFLite with the correct conversion (i.e. when
  // the diagonal recurrent weight matrices are provided as vectors).
  if (attr.getValue().starts_with("indy_lstm_")) {

    TFL_TCresVTEtIsSameAsOp<0, 0>>]> {
  let summary = [{
    Returns a tensor with the provided diagonal and everything else padded with zeros.
  }];

  let description = [{
    Given a diagonal, returns a tensor with the diagonal and everything else padded with zeros.
    Assume diagonal has k dimensions `[I, J, K, ..., N]`, then the output is a tensor of rank `k+1`
    with dimensions `[I, J, K, ..., N, N]` where:

    // We extract the diagonals from k[0] up to and including k[1].
    // Addressing is 0 for the main diagonal. (So k = [0, 0] would just extract
    // the main diagonal). It's negative for subdiagonals (under and to the left
    // of the main diagonal) and positive for superdiagonals (above and to the
    // right of the main diagonal).
    int64_t k[2];

                                     &recurrent_weights_array)))
    return failure();

  // Reshape recurrent weights to vectors if indy behaviour is enabled.
  // IndyLSTMs are a LSTM variant with diagonal recurrent weight
  // matrices. For optimization purposes these are provided as vectors.
  Value recurrent_to_input_weights =
      indy ? mlir::cast<Value>(

  return success();
}

// MatrixDiagV3 is MatrixDiagV2 with an alignment attribute. This attribute
// only has effects when processing multiple diagonals. Since TFLite converts
// MatrixDiagV{2,3} to MatrixDiag, which only takes single-diagonal inputs, we
// can safely ignore this V3 attribute.
// We can't pass `rewriter` by reference because clang-tidy will want it to be

A743          ; valid                                  # 5.1  LATIN SMALL LETTER K WITH DIAGONAL STROKE
A744          ; mapped                 ; A745          # 5.1  LATIN CAPITAL LETTER K WITH STROKE AND DIAGONAL STROKE
A745          ; valid                                  # 5.1  LATIN SMALL LETTER K WITH STROKE AND DIAGONAL STROKE