//   shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
//   shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]
//   ```
//
//   This operation requires that:
//
//   `-1-input.dims() <= dim <= input.dims()`
//
//   This operation is related to `squeeze()`, which removes dimensions of
//   size 1.
Status ExpandDims(AbstractContext* ctx, AbstractTensorHandle* const input,

            %cst = arith.constant dense<3.0> : tensor<32xf32>
            %cmp = "tf.Less"(%read, %cst) : (tensor<32xf32>, tensor<32xf32>) -> tensor<32xi1>
            %dims = arith.constant dense<0> : tensor<1xi32>
            %reduce = "tf.All"(%cmp, %dims) {keep_dims = false} : (tensor<32xi1>, tensor<1xi32>) -> tensor<i1>
            "tf.Yield"(%reduce) : (tensor<i1>) -> ()
        }, {

// Returns the shape of the Tensor referenced by `output` in `graph`
// into `dims`. `dims` must be an array large enough to hold `num_dims`
// entries (e.g., the return value of TF_GraphGetTensorNumDims).
//
// If the number of dimensions in the shape is unknown or the shape is
// a scalar, `dims` will remain untouched. Otherwise, each element of
// `dims` will be set corresponding to the size of the dimension. An

// A sharding with OTHER type may be REPLICATED if:
// 'replicate_on_last_tile_dim' is true OR
// 'last_tile_dims' is not empty
// AND
// other than replicated last tile dims, all other dims are not sharded.
bool IsOtherReplicatedSharding(const xla::OpSharding& xla_sharding);

// Returns whether the sharding is split sharding. i.e. A sharding with OTHER
// type but not replicated.

TF_CAPI_EXPORT extern TF_DataType TF_CheckpointReaderGetVariableDataType(
    TF_CheckpointReader* reader, const char* name);
// Read the shape of a variable and write to `dims`
TF_CAPI_EXPORT extern void TF_CheckpointReaderGetVariableShape(
    TF_CheckpointReader* reader, const char* name, int64_t* dims, int num_dims,
    TF_Status* status);
// Get the number of dimension of a variable
TF_CAPI_EXPORT extern int TF_CheckpointReaderGetVariableNumDims(

      %2 = stablehlo.reshape %1 : (tensor<i32>) -> tensor<1xi32>
      %3 = stablehlo.concatenate %2, %cst_0, dim = 0 : (tensor<1xi32>, tensor<1xi32>) -> tensor<2xi32>
      %4 = stablehlo.dynamic_broadcast_in_dim %arg2, %3, dims = [1] : (tensor<3xf32>, tensor<2xi32>) -> tensor<?x3xf32>
      %5 = stablehlo.add %0, %4 : tensor<?x3xf32>
      return %5 : tensor<?x3xf32>
    }
}

  EXPECT_TRUE(status.ok());
}

absl::StatusOr<std::unique_ptr<Graph>> BuildOpGraphWithOutputShapes() {
  DataType data_type = DT_INT32;
  std::initializer_list<int64_t> dims = {2, 3, 4, 5};
  Tensor tensor(data_type, TensorShape(dims));
  for (int i = 0; i < 2 * 3 * 4 * 5; ++i) {
    tensor.flat<int32>()(i) = i;
  }

  NodeDef node;
  auto builder = NodeDefBuilder("some_node", "Const")

//    could process the following equation by setting the attributes properly:
//    abc,cd->abd.
// 4. The output should be in the form: [batch dims][lhs dims][rhs dims]
bool IsEinsumSupportedByXlaDotV2(StringAttr equation_attr) {
  StringRef equation = equation_attr.getValue();

  if (!absl::StrContains(equation, "->") || !absl::StrContains(equation, ",") ||

    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcat_overflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

      FindOperationOfType<DotGeneralOp>(main_fn)->getResult(0);
  EXPECT_TRUE(HasStaticShape(dot_general_result));
  EXPECT_TRUE(HasStaticShapeAtDims(dot_general_result, /*dims=*/{0}));
  EXPECT_TRUE(HasStaticShapeAtDims(dot_general_result, /*dims=*/{1}));
}

TEST_F(AttrsAndConstraintsTest, HasStaticShapeFailsWithDynamicShapes) {
  OwningOpRef<ModuleOp> module_op = ParseModuleOpString(kModuleDynamic);
  ASSERT_TRUE(module_op);