return op->hasAttr(TF::kReplicationInfoAttr);
}

template <typename Vector, typename Container>
void Append(Vector& a, const Container& b) {
  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;

  Status HandleGeneric(Node* n, std::vector<bool>* should_revisit);
  Status HandleNode(Node* n, std::vector<bool>* should_revisit,
                    bool use_optimistic_mode = false);

  Status GetFrameBasedTopologicalOrder(std::vector<Node*>* order);

  bool IsRootEnter(const Node* n) const {
    return IsEnter(n) && control_flow_info_[n->id()].parent_frame->IsSource();
  }

StatusOr<Operation*> ConvertOp(
    const tflite::OperatorT& op, const std::vector<Value>& vals_map,
    const std::vector<mlir::TensorType>& intermediate_types,
    Value optional_arg_marker,
    const std::vector<std::unique_ptr<tflite::OperatorCodeT>>& op_codes,
    const std::vector<std::string>& func_names,
    const std::vector<std::unique_ptr<tflite::TensorT>>& tensors, Location loc,
    OpBuilder builder,

        "constant folding");
  }

  auto rewrite_subgraph =
      [flr](const std::vector<OutputTensor>& arg_source_tensors,
            std::unique_ptr<Graph>* subgraph,
            std::vector<int>* input_permutation,
            std::vector<int>* output_permutation, NodeDef* node) {
        // Optimize the subgraph.

    }

    /**
     * {@link Vector}の新しいインスタンスを作成して返します。
     *
     * @param <E>
     *            {@link Vector}の要素型
     * @return {@link Vector}の新しいインスタンス
     * @see Vector#Vector()
     */
    public static <E> Vector<E> newVector() {
        return new Vector<>();
    }

    /**
     * {@link Vector}の新しいインスタンスを作成して返します。
     *
     * @param <E>

  auto model_path = tensorflow::io::JoinPath(*g_test_model_dir, model_name);
  return FlatBufferModel::BuildFromFile(model_path.c_str());
}

template <typename T>
std::vector<T> GetAsVector(const flatbuffers::Vector<T>* vec) {
  return std::vector<T>(vec->begin(), vec->end());
}

void VerifyQuantizationScale(
    const QuantizationParameters& float_quant_params,

  return MarkForCompilation(options, debug_options);
}

absl::flat_hash_map<string, std::vector<string>>* GetAllowlistTable() {
  // Table format: category name: {list of TF operations in that category}
  static absl::flat_hash_map<string, std::vector<string>>* result =
      new absl::flat_hash_map<string, std::vector<string>>{
          // Unary
          {"PW",

  // Clears the object.
  void Clear();

  // Protects mutable state of the property vector and of owned
  // properties, whose values may be updated.
  internal::Mutex test_properties_mutex_;

  // The vector of TestPartResults
  std::vector<TestPartResult> test_part_results_;
  // The vector of TestProperties
  std::vector<TestProperty> test_properties_;
  // Running count of death tests.
  int death_test_count_;

      names.insert(cluster);
    }
  }
  return names;
}

absl::flat_hash_map<string, std::vector<string>> GetClusterSets(
    const Graph& g, std::vector<string>* cluster_names = nullptr) {
  CHECK(cluster_names == nullptr || cluster_names->empty());
  absl::flat_hash_map<string, std::vector<string>> cluster_sets;
  for (const auto& p : GetClusters(g)) {
    cluster_sets[p.second].push_back(p.first);
  }

    EXPECT_TRUE(found);
    TF_DeleteBuffer(op_list_buffer);
  }
}

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));