}

TEST_F(ArrayGradTest, TransposeGrad) {
  TensorShape x_shape({5, 2});
  auto x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(x_shape));
  TensorShape y_shape({2, 5});
  auto y = Transpose(scope_, x, {1, 0});
  RunTest(x, x_shape, y, y_shape);
}

TEST_F(ArrayGradTest, ReverseSequenceGrad) {
  TensorShape shape({5, 2, 5});
  auto x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(shape));

    // Broadcast the scales and zero points to match the target size, which is
    // usually the axis-th dimension of the target type. Currently, it covers
    // two cases:
    // - for Transpose, the data layout is changed so the `dim[axis]` still
    // equals to the `scales_size`. The broadcast skips;
    // - for Reshape, the data layout isn't changed but the innermost dimension

namespace tensorflow {

// Default PaddedShapeFn implementation that simply returns the unpadded
// on-device shape. This is accurate for CPU and GPU devices that neither
// transpose nor pad tensors.
Status DefaultPaddedShapeFn(const Tensor& tensor, xla::Shape* shape) {
  const tensorflow::XlaTensor* xla_tensor =
      tensorflow::XlaTensor::FromTensor(&tensor);
  if (xla_tensor == nullptr) {

      %outputs_57, %control_58 = tf_executor.island wraps "tf.Transpose"(%outputs_55, %outputs_47) {_tpu_replicate = "cluster_sample_sequence", device = ""} : (tensor<*xf32>, tensor<2xi32>) -> tensor<*xf32>

  }
};

class PropagateTransposedPerAxisQuantDim
    : public OpRewritePattern<TFL::TransposeOp> {
 public:
  explicit PropagateTransposedPerAxisQuantDim(MLIRContext* context)
      : OpRewritePattern<TFL::TransposeOp>(context) {}
  LogicalResult matchAndRewrite(TFL::TransposeOp transpose_op,
                                PatternRewriter& rewriter) const override {

        TypeID::get<TF::TensorScatterSubOp>(),
        TypeID::get<TF::TPUEmbeddingActivationsOp>(),
        TypeID::get<TF::TopKUniqueOp>(),
        TypeID::get<TF::TopKWithUniqueOp>(),
        TypeID::get<TF::TransposeOp>(),
        TypeID::get<TF::TridiagonalSolveOp>(),
        TypeID::get<TF::TridiagonalMatMulOp>(),
        TypeID::get<TF::TruncateDivOp>(),
        TypeID::get<TF::TruncatedNormalOp>(),

TF_CAPI_EXPORT extern int TFE_TensorDebugInfoOnDeviceNumDims(
    TFE_TensorDebugInfo* debug_info);

// Returns the number of elements in dimension `dim_index`.
// Tensor representation on device can be transposed from its representation
// on host. The data contained in dimension `dim_index` on device
// can correspond to the data contained in another dimension in on-host

                  @Override
                  Table<String, Integer, Character> createTable() {
                    Table<Integer, String, Character> original = TreeBasedTable.create();
                    return Tables.transpose(original);
                  }
                })
            .named("TransposedTable.cellSet")
            .withFeatures(
                CollectionSize.ANY,
                CollectionFeature.REMOVE_OPERATIONS,

        } else if (!MAVEN_RESOLVER_TRANSPORT_AUTO.equals(transport)) {
            throw new IllegalArgumentException("Unknown resolver transport '" + transport
                    + "'. Supported transports are: " + MAVEN_RESOLVER_TRANSPORT_WAGON + ", "
                    + MAVEN_RESOLVER_TRANSPORT_APACHE + ", " + MAVEN_RESOLVER_TRANSPORT_JDK + ", "
                    + MAVEN_RESOLVER_TRANSPORT_AUTO);
        }

  let constructor = "CreateReduceTypePrecisionPass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
}

def PushTransposeThroughEwisePass : Pass<"push-transpose-through-ewise", "mlir::ModuleOp"> {
  let summary = "TODO";
  let constructor = "CreatePushTransposeThroughEwisePass()";
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];