new_axis_mask &= ~ellipsis_mask;

    DenseIntElementsAttr begin_dense_elem_attr;
    Value begin = strided_slice_op.getBegin();
    auto begin_ranked_attr_type =
        mlir::dyn_cast<RankedTensorType>(begin.getType());
    if (!begin_ranked_attr_type ||
        !matchPattern(begin, m_Constant(&begin_dense_elem_attr))) {
      return failure();
    }

    DenseIntElementsAttr end_dense_elem_attr;

  op->setAttr(kDevice, builder.getStringAttr(""));
  op->setAttr(kLower, builder.getBoolAttr(true));
}

std::vector<Value> ResultsAsVector(Operation* op, int begin, int num) {
  int end = begin + num;
  std::vector<Value> vec;
  vec.reserve(end - begin);
  for (int i = begin; i < end; ++i) vec.push_back(op->getResult(i));
  return vec;
}

void GatherOpsForExtraction(mlir::SetVector<Operation*>* operations,

        }
      }
    }
    auto it = simplified_ops.begin();
    while (it != simplified_ops.end()) {
      if (to_remove.contains(*it)) {
        it = simplified_ops.erase(it);
      } else {
        ++it;
      }
    }
    simplified_ops.insert(simplified_ops.end(), to_add.begin(), to_add.end());
  }

  // If all ops contain the same subop, then factor it out thanks to the

  int64_t feature_dim = GetTensorFeatureDimIndex(rank, format);
  llvm::SmallVector<int64_t, 4> dims_to_reduce(rank - 1);
  std::iota(dims_to_reduce.begin(), dims_to_reduce.begin() + feature_dim, 0);
  std::iota(dims_to_reduce.begin() + feature_dim, dims_to_reduce.end(),
            feature_dim + 1);
  return GetI64ElementsAttr(dims_to_reduce, builder);
}

                                             status);
    EXPECT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
    EXPECT_TRUE(
        std::equal(std::begin(list), std::end(list), std::begin(values)));
    TF_DeleteStatus(status);
    return static_cast<void*>(s);
  };

  AttrValue v;
  int64_t attr_in[] = {1, 2, 3, 4};
  SetAttrValue(gtl::ArraySlice<int64_t>(attr_in, 4), &v);

pub    5208812E1E4A6DB0
uid    Gradle Inc. <******@****.***>

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: BCPG v1.68

mQENBFxaxWYBCADI4/gRCJYfXwZYdUoEGlAlCfRgABy90rvebzcs8MKtolAbPVkG
iqnjftXd28sZhEDx9YJrUfmzspdrYmU7hy1kgV1/WGIcWyTExTH3bqlnaIWnnTxA
HD0x4NJ2AzmX5VO8LxhqGID+BErrv7uGZvVmJT6trqUIcKeNEq7mzdDJKqTBY4cw
q+Dm8P0vs4IFTD8q5f1Vr78FmUth2srIBmsIH1wNV1nAUTmQppNBFlCmcvnWTYI1
0UMcsFFrJ2pFT1yP2AEGUNl4Lgj4hmVHZwX38/lu9pQ7iWtHSLOwZsfuC34/goS+

  // CHECK-LABEL: strided_slice_with_constant_attributes
  // CHECK-DAG: [[BEGIN:%cst.*]] = arith.constant dense<[-1, 0, 0]> : tensor<3xi32>
  // CHECK-DAG: [[END:%cst.*]] = arith.constant dense<[0, 10, 10]> : tensor<3xi32>
  // CHECK-DAG: [[STRIDES:%cst.*]] = arith.constant dense<1> : tensor<3xi32>

  ASSERT_EQ(clusters3.size(), 1);

  // clusters0 and clusters2 should be the same
  TF_EXPECT_OK(cluster_names_match(*clusters0.begin(), *clusters2.begin()));

  // clusters1 and clusters3 should also be the same
  TF_EXPECT_OK(cluster_names_match(*clusters1.begin(), *clusters3.begin()));

  // clusters0/2 should differ from clusters1/3
}

TEST(XlaCompilationTest, ClusterSessionName) {

    ZeroIntAttr:$_,
    ZeroIntAttr:$_,
    ConstBoolAttrFalse),
  (TFL_SliceOp $input,
    (Arith_ConstantOp $begin),
    (Arith_ConstantOp (GetOffSet $begin, $end))),
  [(IsAllOnesConstant $stride),
   (HasNonNegativeValues $begin),
   (HasNonNegativeOffset $begin, $end)]>;

def GetNumElementsOrOne: NativeCodeCall<"GetNumElementsOrOne($0.getType())">;

      SmallVector<int32_t, 4> new_element_shape_values;

      auto int_values = dense_elem_attr.getValues<APInt>();
      for (auto it = int_values.begin(); it != int_values.end(); ++it) {
        auto dim_value = (*it).getSExtValue();
        if (it == int_values.begin() && dim_value == -1) {
          if (!default_to_single_batch_) {
            const char *error_info =