#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
constexpr ll INF = 1000000000;
namespace XelmhMatrix {
class Subscript {
 public:
  using subscript_type = long long;
  subscript_type i;
  subscript_type j;
  Subscript(subscript_type vi, subscript_type vj) : i(vi), j(vj) {}
  Subscript() : i(0), j(0) {}
  Subscript operator+(const Subscript T) const { return {i + T.i, j + T.j}; }
  Subscript operator-(const Subscript T) const { return {i - T.i, j - T.j}; }
  void operator+=(const Subscript T) {
    i += T.i;
    j += T.j;
  }
  void operator-=(const Subscript T) {
    i -= T.i;
    j -= T.j;
  }
  bool operator==(const Subscript T) const { return i == T.i && j == T.j; }
};
std::ostream& operator<<(std::ostream& os, Subscript p) {
  return os << "i:" << p.i << ",j:" << p.j;
}
template <class value_type>
class Matrix {
  using mat_type = std::vector<std::vector<value_type>>;
  using size_type = unsigned long long;
  mat_type values;
  size_type row;
  size_type column;

 public:
  explicit Matrix(const size_type N, const size_type M)
      : values(N, std::vector<value_type>(M)), row(N), column(M) {}
  value_type& operator[](const Subscript ij) { return values[ij.i][ij.j]; }
  const value_type& operator[](const Subscript ij) const {
    return values[ij.i][ij.j];
  }
  std::vector<value_type>& operator[](const Subscript::subscript_type x) {
    return values[x];
  }
  const std::vector<value_type>& operator[](
      const Subscript::subscript_type x) const {
    return values[x];
  }
  bool is_inside(Subscript ij) {
    return 0 <= ij.i && ij.i < row && 0 <= ij.j && ij.j < column;
  }
  bool is_inside(size_type i, size_type j) {
    return 0 <= i && i < row && 0 <= j && j < column;
  }
  size_type row_size() const { return row; }
  size_type column_size() const { return column; }
};
template <class value_type>
std::istream& operator>>(std::istream& is, Matrix<value_type>& mat) {
  for (unsigned long long i = 0; i < mat.row_size(); ++i) {
    for (unsigned long long j = 0; j < mat.column_size(); ++j) {
      is >> mat[i][j];
    }
  }
  return is;
}
template <class value_type>
std::ostream& operator<<(std::ostream& os, const Matrix<value_type>& mat) {
  unsigned long long endpoint = mat.column_size() - 1;
  unsigned long long iend, jend;
  iend = mat.row_size();
  jend = mat.column_size();
  for (unsigned long long i = 0; i < iend; ++i) {
    for (unsigned long long j = 0; j < jend; ++j) {
      os << mat[i][j] << " \n"[j == endpoint];
    }
  }
  return os;
}
std::array<Subscript, 4> move_directions{Subscript{1, 0}, Subscript{-1, 0},
                                         Subscript{0, 1}, Subscript{0, -1}};
}  // namespace XelmhMatrix
using namespace XelmhMatrix;
void solve(istream& cin) {
  ll N, M;
  cin >> N >> M;
  if (!cin) return;
  Matrix<ll> mat(N, M);
  cin >> mat;
  vector<map<ll, ll>> rows(N), columns(M);
  for (int x = 0; x < N; ++x) {
    vector<ll> row(M);
    for (int i = 0; i < M; ++i) {
      row[i] = mat[x][i];
    }
    sort(row.begin(), row.end());
    ll rank = 0;
    ll pre = 0;
    for (auto&& r : row) {
      if (r == pre) continue;
      pre = r;
      rank++;
      rows[x][r] = rank;
    }
  }
  for (int x = 0; x < M; ++x) {
    vector<ll> col(N);
    for (int i = 0; i < N; ++i) {
      col[i] = mat[i][x];
    }
    sort(col.begin(), col.end());
    ll rank = 0;
    ll pre = 0;
    for (auto&& r : col) {
      if (r == pre) continue;
      pre = r;
      rank++;
      columns[x][r] = rank;
    }
  }
  Matrix<ll> ans(N, M);
  for (int i = 0; i < N; ++i) {
    for (int j = 0; j < M; ++j) {
      ll row_max = rows[i].size();
      ll col_max = columns[j].size();
      ll val = mat[i][j];
      ll rv = rows[i][val], cv = columns[j][val];
      if (rv != cv) {
        if (rv < cv) {
          row_max += cv - rv;
        } else {
          col_max += rv - cv;
        }
      }
      ans[i][j] = max(row_max, col_max);
    }
  }
  cout << ans << endl;
}
int main(int argc, char* argv[]) {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << setprecision(16) << scientific;
  solve(cin);
  return 0;
}
