// body and condition. The sets of keys of the two maps must be the same.
llvm::SmallDenseMap<int64_t, ResourceArgUseInfo> MergeArgResourceUseInfo(
    const llvm::SmallDenseMap<int64_t, ResourceArgUseInfo>& infos0,
    const llvm::SmallDenseMap<int64_t, ResourceArgUseInfo>& infos1) {
  llvm::SmallDenseMap<int64_t, ResourceArgUseInfo> result;
  for (const auto& entry : infos0) {
    auto info1_it = infos1.find(entry.getFirst());

    SmallVector<int64_t> start_indices(input_rank, 0);
    SmallVector<int64_t> slice_sizes = reshaped_permuted_shape;
    SmallVector<int64_t> strides(input_rank, 1);
    auto crop_values = llvm::to_vector<4>(crops.getValues<APInt>());
    for (int i = 0; i < block_rank; ++i) {
      int64_t crop_start = crop_values[i * 2].getSExtValue();
      int64_t crop_end = crop_values[i * 2 + 1].getSExtValue();

  }
}

void TestEncodeDecode(int line, const std::vector<string>& data) {
  const int64_t n = data.size();
  Status status;
  for (const std::vector<int64_t>& dims :
       std::vector<std::vector<int64_t>>{{n}, {1, n}, {n, 1}, {n / 2, 2}}) {
    // Create C++ Tensor
    Tensor src(tensorflow::DT_STRING, TensorShape(dims));
    for (int64_t i = 0; i < src.NumElements(); ++i) {
      src.flat<tstring>()(i) = data[i];
    }

        input_size - begin_shape[0] + 1 + absl::popcount(new_axis_mask);

    int64_t begin_mask = strided_slice_op.getBeginMask();
    int64_t end_mask = strided_slice_op.getEndMask();
    int64_t revised_begin_mask = 0;
    int64_t revised_end_mask = 0;
    int64_t revised_shrink_axis_mask = 0;
    int64_t revised_new_axis_mask = 0;

    SmallVector<int32_t, 4> padded_begin;

  // not contracted nor batched.
  int64_t GetFilterQuantizationDimension(
      const stablehlo::DotDimensionNumbersAttr& dot_dimension_numbers,
      const int64_t filter_rank) const {
    // Register all dimensions as candidates.
    auto seq_range = llvm::seq(int64_t{0}, filter_rank);
    SmallVector<int64_t> quantization_dimension_candidates(seq_range.begin(),

      result_rank = element_type.getRank() + 1;
      int64_t leading_dim_v = -1;
      ElementsAttr element_attr;
      if (matchPattern(leading_dim, m_Constant(&element_attr))) {
        leading_dim_v = element_attr.getValues<APInt>()[0].getSExtValue();
      }
      SmallVector<int64_t, 4> result_shape = {leading_dim_v};
      ArrayRef<int64_t> shape = element_type.getShape();

 protected:
  explicit Predicate(int64_t id) : id_(id) {}

 private:
  const int64_t id_;

  Predicate(const Predicate&) = delete;
  void operator=(const Predicate&) = delete;
};

// Represents a logical conjunction of a set of predicates.
class AndPredicate : public Predicate {
 public:
  explicit AndPredicate(int64_t id, std::vector<Predicate*> operands)

  // so not passing it during conversion. This design might change if needed.
  ArrayRef<double> scales = qtype.getScales();
  ArrayRef<int64_t> zero_points = qtype.getZeroPoints();
  const int num_channels = scales.size();
  TensorType scale_type = RankedTensorType::get(
      {static_cast<int64_t>(num_channels)}, rewriter.getF32Type());
  TensorType zero_point_type = scale_type.clone(rewriter.getI32Type());

                .session_metadata()
                .name()
          : ""}
      .Run();
}

std::atomic<int64_t>* GetPointerToFuel(int64_t initial_value) {
  static std::atomic<int64_t>* fuel = [&]() {
    std::atomic<int64_t>* fuel = new std::atomic<int64_t>;
    *fuel = initial_value;
    return fuel;
  }();

  return fuel;
}

}  // anonymous namespace

  a.insert(a.end(), b.begin(), b.end());
}

template <typename Vector>
void Append(Vector& a, const Vector& b) {
  a.insert(a.end(), b.begin(), b.end());
}

int64_t GetNumOps(func::FuncOp func) {
  int64_t num_ops = 0;
  for (auto it = func.begin(); it != func.end(); ++it) ++num_ops;
  return num_ops;
}

std::vector<Value> ResultsAsVector(Operation* op) {
  std::vector<Value> vec;