requested_read_length = INT32_MAX;
    else
      requested_read_length = n;

    // `pread` returns a `ssize_t` on POSIX, but due to interface being
    // cross-platform, return type of `Read` is `int64_t`.
    int64_t r = int64_t{pread(posix_file->fd, dst, requested_read_length,
                              static_cast<off_t>(offset))};
    if (r > 0) {
      dst += r;
      offset += static_cast<uint64_t>(r);

  auto* cc_agent = reinterpret_cast<tsl::CoordinationServiceAgent*>(agent);
  return cc_agent->IsInitialized();
}

void TF_CoordinationServiceInsertKeyValue(const char* key, int64_t key_size,
                                          const char* value, int64_t value_size,
                                          TF_CoordinationServiceAgent* agent,
                                          TF_Status* status) {

  return num_dims;
}

int64_t TFE_TensorHandleNumElements(TFE_TensorHandle* h, TF_Status* status) {
  if (h == nullptr) {
    status->status = tensorflow::errors::InvalidArgument("Invalid handle");
    return -1;
  }

  int64_t num_elements = -1;
  status->status = tensorflow::unwrap(h)->NumElements(&num_elements);
  return num_elements;
}

int64_t TFE_TensorHandleDim(TFE_TensorHandle* h, int dim_index,

          dot.getDotDimensionNumbers();
      ArrayRef<int64_t> rhs_contracting_dims =
          dimension_numbers.getRhsContractingDimensions();
      ArrayRef<int64_t> rhs_batching_dims =
          dimension_numbers.getRhsBatchingDimensions();
      int64_t rank = dot.getRhs().getType().cast<TensorType>().getRank();
      for (int i = 0; i < rank; ++i) {

    set_arg_data(1, data);
  }
  int64_t* arg1_data() {
    return static_cast<int64_t*>(arg_data(1));
  }
  int64_t& arg1(size_t dim0, size_t dim1) {
    return (*static_cast<int64_t(*)[3][4]>(
        arg_data(1)))[dim0][dim1];
  }
  const int64_t* arg1_data() const {
    return static_cast<const int64_t*>(arg_data(1));
  }
  const int64_t& arg1(size_t dim0, size_t dim1) const {

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_dialect.h"

namespace mlir::quant {
namespace {

void PackOperandTestHelper(
    const llvm::SmallVector<int64_t>& unpacked_shape,
    const llvm::SmallVector<int8_t>& unpacked_values, int pack_dim,
    const llvm::SmallVector<int64_t>& expected_packed_shape,
    const llvm::SmallVector<int8_t>& expected_packed_values) {
  MLIRContext context;

#include <vector>

#include "tensorflow/core/platform/types.h"

struct TFE_TensorDebugInfo {
  explicit TFE_TensorDebugInfo(const std::vector<int64_t>& dims)
      : dev_dims(dims) {}

  // Fully-padded, minor-to-major.
  std::vector<int64_t> dev_dims;
};

};

struct TFE_MonitoringIntGauge0 : TFE_MonitoringGauge<int64_t, 0> {
  using TFE_MonitoringGauge::TFE_MonitoringGauge;
};
struct TFE_MonitoringIntGauge1 : TFE_MonitoringGauge<int64_t, 1> {
  using TFE_MonitoringGauge::TFE_MonitoringGauge;
};
struct TFE_MonitoringIntGauge2 : TFE_MonitoringGauge<int64_t, 2> {
  using TFE_MonitoringGauge::TFE_MonitoringGauge;
};

  // Keeps track of dtype counts per op.
  void CountOp(DenseMap<StringRef, llvm::StringMap<int64_t>> &op_count_map,
               StringRef op_name, StringRef dtype);

 private:
  llvm::StringMap<int64_t> op_with_dialect_count_;
  DenseMap<StringRef, llvm::StringMap<int64_t>> op_dtype_count_;
  llvm::StringMap<int64_t> dialect_count_;
  llvm::StringMap<StringRef> dialect_name_of_;
  llvm::StringMap<StringRef> op_name_of_;

                                                  float data[], int64_t dims[],
                                                  int num_dims);

// Get a Matrix TensorHandle with given float values and dimensions
TFE_TensorHandle* TestTensorHandleWithDimsFloat(TFE_Context* ctx, float data[],
                                                int64_t dims[], int num_dims);