// CHECK-LABEL: main
// CHECK: return %arg0 : tensor<5x7xf32>
}

// - transpose
//
func.func @transpose_2d(%arg0: tensor<2x3xf32>) -> tensor<3x2xf32> {
  %0 = "mhlo.transpose"(%arg0) <{permutation = dense<[1, 0]> : tensor<2xi64>}> : (tensor<2x3xf32>) -> tensor<3x2xf32>
  func.return %0 : tensor<3x2xf32>

// CHECK-LABEL:   transpose_2d

Value Transpose(OpBuilder* builder, Value value_to_transpose,
                SmallVector<int32_t, 4> perm, RankedTensorType original_type,
                mlir::Location location) {
  // Create a constant op for transpose permutation.
  auto perm_op = CreateI32DenseConst(builder, perm, location);

  // Create tensor type for the transpose result.
  auto transpose_type = original_type;
  auto transpose_shape =

				t.Errorf("Write() = (%d, %v); want (%d, nil)", n, err, len(input))
			}
		}

		// Since each read is independent, the only guarantee about the output
		// is that it is a permutation of the input in readSized groups.
		got := make([]byte, 0, count*len(input))
		for i := 0; i < cap(c); i++ {
			got = append(got, (<-c)...)
		}
		got = sortBytesInGroups(got, readSize)

struct FoldTransposeOp : public OpRewritePattern<TransposeOp> {
  explicit FoldTransposeOp(MLIRContext* context)
      : OpRewritePattern<TransposeOp>(context, 1) {}

  // Computes the permutation of a constant `input_tensor` according to `perm`.
  // The function recursively traverses the dimensions of the output tensor in
  // a row-major order and writes the value in the output tensor into
  // `new_values`.

	for i, src := range sources {
		orig[i] = mustParse(src)
	}

	// run the test for all order permutations of the incoming files
	for _, perm := range [][len(sources)]int{
		{0, 1, 2},
		{0, 2, 1},
		{1, 0, 2},
		{1, 2, 0},
		{2, 0, 1},
		{2, 1, 0},
	} {
		// create file order permutation
		files := make([]*syntax.File, len(sources))
		for i := range perm {
			files[i] = orig[perm[i]]
		}

  %permutation = "tf.Const"() {value = dense<[2, 1, 0]> : tensor<3xi32>} : () -> (tensor<3xi32>)
  // CHECK: "mhlo.transpose"
  %0 = "tf.Transpose"(%arg0, %permutation) : (tensor<1x2x3xf32>, tensor<3xi32>) -> tensor<3x2x1xf32>
  func.return %0 : tensor<3x2x1xf32>
}

// -----

// CHECK-LABEL: @transpose_3d
func.func @transpose_3d(%arg0: tensor<1x2x3xf32>) -> tensor<3x2x1xf32> {

	for i, src := range sources {
		orig[i] = mustParse(fset, src)
	}

	// run the test for all order permutations of the incoming files
	for _, perm := range [][len(sources)]int{
		{0, 1, 2},
		{0, 2, 1},
		{1, 0, 2},
		{1, 2, 0},
		{2, 0, 1},
		{2, 1, 0},
	} {
		// create file order permutation
		files := make([]*ast.File, len(sources))
		for i := range perm {
			files[i] = orig[perm[i]]
		}

    // Create a 1D I32 tensor for representing the dimension permutation.
    auto permuation_tensor_type =
        RankedTensorType::get({input_rank}, rewriter.getIntegerType(32));
    llvm::SmallVector<Attribute, 4> permute;
    permute.reserve(input_rank);
    // First create an identity permutation tensor.
    for (int i = 0; i < input_rank; i++) {

  (TFL_TransposeOp
    (TFL_TransposeOp:$transpose_out1 $input, (Arith_ConstantOp:$permutation1 $p1)),
    (Arith_ConstantOp:$permutation2 $p2)),
  (TFL_TransposeOp $input,
    (Arith_ConstantOp (RemapPermutation $permutation1, $permutation2))),
  [(HasOneUse $transpose_out1)]>;

// Convert expand_dims to reshape if possible.
def ConvertExpandDimsToReshape : Pat<
  (TFL_ExpandDimsOp:$expand_dims_op $input, $dim),

      if (perm_type.getNumElements() != input_type.getRank()) {
        return transpose_op.emitOpError(
            "perm tensor elements size is not equal to input tensor rank");
      }
    }

    // Get permutation axes of the TransposeOp
    DenseIntElementsAttr perm;
    if (!matchPattern(transpose_op.getPerm(), m_Constant(&perm))) {
      return failure();
    }

    SmallVector<int64_t, 4> axes;