#include <bits/stdc++.h>
template <typename element_type>
void print(const std::vector<element_type>& v);
void decide(bool result);
using namespace std;
class disjoint_union {
 private:
  vector<vector<pair<int, int>>> parent;
  vector<vector<int>> rank;
  vector<vector<int>> size;

 public:
  disjoint_union(int rows, int columns);
  pair<int, int> find(pair<int, int> cell);
  int count(pair<int, int> cell);
  void unionize(pair<int, int> a, pair<int, int> b);
};
const int dirs = 4;
const int dx[dirs] = {0, 0, 1, -1};
const int dy[dirs] = {1, -1, 0, 0};
const pair<int, int> bad(-1, -1);
void fill_result(pair<int, int> cell, int& stacks, int height,
                 const vector<vector<int>>& table, vector<vector<int>>& result);
bool has_edge(pair<int, int> cell, pair<int, int> neighbor,
              const vector<vector<int>>& table, int height);
int main() {
  int rows, columns;
  long long goal_volume;
  while (cin >> rows >> columns >> goal_volume) {
    vector<vector<int>> table(rows, vector<int>(columns));
    map<int, vector<pair<int, int>>> heights;
    for (int r = 0; r < rows; r++)
      for (int c = 0; c < columns; c++) {
        cin >> table[r][c];
        heights[-table[r][c]].push_back(make_pair(r, c));
      }
    disjoint_union du(rows, columns);
    pair<int, int> solve_cell = bad;
    for (pair<const int, vector<pair<int, int>>>& p : heights) {
      int height = -p.first;
      for (pair<int, int> cell : p.second)
        for (int dir = 0; dir < dirs; dir++) {
          pair<int, int> neighbor(cell.first + dx[dir], cell.second + dy[dir]);
          if (has_edge(cell, neighbor, table, height))
            du.unionize(cell, neighbor);
        }
      if (goal_volume % height == 0)
        for (pair<int, int> cell : p.second)
          if (du.count(cell) >= goal_volume / height) solve_cell = cell;
    }
    decide(solve_cell != bad);
    if (solve_cell != bad) {
      vector<vector<int>> result(rows, vector<int>(columns));
      int height = table[solve_cell.first][solve_cell.second];
      int stacks = goal_volume / height;
      fill_result(solve_cell, stacks, height, table, result);
      for (int i = 0; i < result.size(); i++) print(result[i]);
    }
  }
}
bool has_edge(pair<int, int> cell, pair<int, int> neighbor,
              const vector<vector<int>>& table, int height) {
  if (neighbor.first < 0 || neighbor.first >= table.size() ||
      neighbor.second < 0 || neighbor.second >= table[neighbor.first].size())
    return false;
  return height <= table[neighbor.first][neighbor.second];
}
disjoint_union::disjoint_union(int rows, int columns)
    : parent(rows, vector<pair<int, int>>(columns)),
      rank(rows, vector<int>(columns, 0)),
      size(rows, vector<int>(columns, 1)) {
  for (int r = 0; r < rows; r++)
    for (int c = 0; c < columns; c++) parent[r][c] = make_pair(r, c);
}
pair<int, int> disjoint_union::find(pair<int, int> cell) {
  if (parent[cell.first][cell.second] == cell) return cell;
  return parent[cell.first][cell.second] =
             find(parent[cell.first][cell.second]);
}
int disjoint_union::count(pair<int, int> cell) {
  pair<int, int> root = find(cell);
  return size[root.first][root.second];
}
void disjoint_union::unionize(pair<int, int> a, pair<int, int> b) {
  pair<int, int> a_root = find(a), b_root = find(b);
  if (a_root == b_root) return;
  pair<int, int> root;
  if (rank[a_root.first][a_root.second] < rank[b_root.first][b_root.second])
    root = b_root;
  else if (rank[a_root.first][a_root.second] >
           rank[b_root.first][b_root.second])
    root = a_root;
  else {
    root = a_root;
    rank[a_root.first][a_root.second]++;
  }
  size[root.first][root.second] = count(a_root) + count(b_root);
  parent[a_root.first][a_root.second] = root;
  parent[b_root.first][b_root.second] = root;
}
void decide(bool result) {
  if (result)
    cout << "YES\n";
  else
    cout << "NO\n";
}
template <typename element_type>
void print(const std::vector<element_type>& v) {
  for (int i = 0; i < v.size(); i++) {
    if (i) std::cout << ' ';
    std::cout << v[i];
  }
  std::cout << '\n';
}
void fill_result(pair<int, int> cell, int& stacks, int height,
                 const vector<vector<int>>& table,
                 vector<vector<int>>& result) {
  if (result[cell.first][cell.second]) return;
  if (stacks <= 0) return;
  result[cell.first][cell.second] = height;
  stacks--;
  if (stacks <= 0) return;
  for (int dir = 0; dir < dirs; dir++) {
    pair<int, int> neighbor(cell.first + dx[dir], cell.second + dy[dir]);
    if (has_edge(cell, neighbor, table, height))
      fill_result(neighbor, stacks, height, table, result);
  }
}
