concat_dim);
      result = concat_op.getResult();
    }

    rewriter.replaceOp(op, result);
    return success();
  }
};

// Decomposes Softmax and LogSoftmax to primitive TF ops, using the following
// formulas:
//
//     softmax = div(exp(logits), sum(exp(logits)))
//     log_softmax = sub(logits, log(sum(exp(logits))))
//

// RUN: tfr-opt %s -tfr-decompose -verify-diagnostics | FileCheck %s

// Definitions for ops that are being used in the tests.
// ex) tf.MyOp refers to tfr.func @tf__my_op

// CHECK-LABEL: @tf__fake_no_op
tfr.func @tf__fake_no_op(%arg0: !tfr.tensor) -> !tfr.tensor {
  tfr.return %arg0 : !tfr.tensor

// CHECK-NEXT: tfr.return %arg0 : !tfr.tensor
}

// CHECK-LABEL: @tf__intermediate
tfr.func @tf__intermediate(%arg0: !tfr.tensor) -> !tfr.tensor {

// non-generational and non-compacting. Allocation is done using size segregated per P allocation
// areas to minimize fragmentation while eliminating locks in the common case.
//
// The algorithm decomposes into several steps.
// This is a high level description of the algorithm being used. For an overview of GC a good
// place to start is Richard Jones' gchandbook.org.
//

// RUN: tf-opt %s -tf-device-decompose-resource-ops | FileCheck -check-prefixes=CHECK,ALWAYS-DECOMPOSE %s
// RUN: tf-opt %s -tf-device-decompose-resource-ops-in-cluster | FileCheck -check-prefixes=CHECK,CLUSTER-ONLY %s

// Tests different behavior of two passes if the op is outside cluster
// tf-device-decompose-resource-ops would always decompose the resource op.
// tf-device-decompose-resource-ops-in-cluster would not decompose ops outside

```
### `-tf-data-optimization`

_Performs tf.data optimizations_

### `-tf-decompose-reduce-dataset`

_Decomposes ReduceDataset op into dataset operations._

  Decomposes ReduceDataset op into a while loop that iterates the dataset and calls
  into the reduction function.  This decomposition is only done if the

TEST(NumericalUtils, QuantizeMultiplier) {
  // Decompose multiplier larger than 1.
  ASSERT_FLOAT_EQ(ComposeScale(QuantizeMultiplier(1.0e6)), 1.0e6);
  ASSERT_FLOAT_EQ(ComposeScale(QuantizeMultiplier(1.0e3)), 1.0e3);
  ASSERT_FLOAT_EQ(ComposeScale(QuantizeMultiplier(10.)), 10.);
  ASSERT_FLOAT_EQ(ComposeScale(QuantizeMultiplier(5.)), 5.);
  ASSERT_FLOAT_EQ(ComposeScale(QuantizeMultiplier(2.)), 2.);

  // Decompose multiplier between 1.0 and 1e-6.

// RUN: tf-opt --tfl-decompose-hybrid-quantization --verify-each %s | FileCheck %s

// CHECK-LABEL: @test_conv2d_float
func.func @test_conv2d_float(%arg0: tensor<1x32x32x8xf32>) -> tensor<1x32x32x16xf32> {
  // CHECK-DAG: %[[VAL0:.+]] = "tfl.pseudo_const"() <{value = dense<42> : tensor<16x1x1x8xi8>}>
  // CHECK-DAG: %[[VAL1:.+]] = "tfl.pseudo_const"() <{value = dense<1> : tensor<16x1x1x8xi8>}>

  let constructor = "mlir::odml::CreateComposeUniformQuantizedTypePass()";
  let description = [{
    Identifies uniform quantization patterns and composes them to uniform
    quantized types. This pass targets a specific set of models that are
    quantized from the framework level, which produces "decomposed"
    quantization patterns due to the limitations of the framework.

    In the long term it is desired that the framework produces uniform

      ),
      (TF_AssignVariableOp $accum_resource, $new_accum, (CreateConstBoolAttrFalse)),
    ]
  >;

// ResourceApplyAdagrad op can be canonicalized to ResourceApplyAdagradV2 with
// zero epsilon and then decomposed using DecomposeResourceApplyAdagradV2
// pattern.
def DecomposeResourceApplyAdagrad :
  Pattern<
    (TF_ResourceApplyAdagradOp $var_resource, $accum_resource, $lr, $grad,
       $use_locking, $update_slots),

                    .Input(src_list)
                    .Finalize(&test_node);
  EXPECT_TRUE(status.ok());
  auto decomposed = test_ctx_->ExpandNode(test_node, "test");
  EXPECT_TRUE(decomposed.ok());
  std::vector<NodeAndType> expected_results{{"Identity", DT_FLOAT}};
  EXPECT_THAT(NodesSequenceOf(decomposed.value()),
              ElementsAreArray(expected_results));
}

TEST_F(TFRDecomposeContextTest, FLOAT_3_ins) {