#include <bits/stdc++.h>
using namespace std;


class DecreasingHandler {


 public:
  explicit DecreasingHandler(int n) {
    arr_.reserve(n);
    pref_.reserve(n + 1);
  }

  void add_vec(vector<long long>&& vec) {
    arr_.insert(arr_.end(), vec.begin(), vec.end());
  }

  void init() {
    pref_.resize(arr_.size() + 1);
    sort(arr_.begin(), arr_.end(), greater<long long>());
    for (int i = 0; i < (int) arr_.size(); i++) {
      pref_[i+1] = pref_[i] + arr_[i];
    }
  }

  long long get_opt(int k) const {
    return pref_[min(k, (int) arr_.size())];
  }

  pair<int, long long> get_all() const {
    return make_pair((int) arr_.size(), pref_.back());
  }


 private:
  vector<long long> arr_;
  vector<long long> pref_;
};

class SumVector {

 public:
  SumVector(vector<long long> vec) : vec_(std::move(vec)) {
    pref_.resize(vec_.size() + 1);
    for (int i = 0; i < (int) vec_.size(); i++) {
      pref_[i+1] = pref_[i] + vec_[i];
    }
  }

  const long long& operator[](int ind) const {
    return vec_[ind];
  }

  size_t size() const {
    return vec_.size();
  }

  long long get_sum() const {
    return pref_.back();
  }

  friend bool operator<(const SumVector& lhs, const SumVector& rhs) {
    return lhs.get_sum() < rhs.get_sum();
  }

  friend bool operator>(const SumVector& lhs, const SumVector& rhs) {
    return lhs.get_sum() > rhs.get_sum();
  }

  long long get_sum(int l, int r) const {
    return pref_[r + 1] - pref_[l];
  }

 private:
  vector<long long> vec_;
  vector<long long> pref_;
};

class IncreasingHandler {



 public:
  explicit IncreasingHandler(int n, int m) : m_(m) {
    arr_.reserve(n);
  }

  void add_vec(vector<long long>&& vec) {
    arr_.push_back(move(vec));
  }

  void init() {
    n_ = arr_.size();
    sort(arr_.begin(), arr_.end(), std::greater<SumVector>());
    global_pref_.resize(arr_.size() + 1);
    for (int i = 0; i < (int) arr_.size(); i++) {
      global_pref_[i+1] = global_pref_[i] + arr_[i].get_sum();
    }
  }

  vector<long long> get_all(int k) {
    if (n_ == 0) {
      return {0};
    }
    vector<long long> ans(n_ * m_ + 1);
    for (int i = 0; i < m_; i++) {
      long long sub = arr_[0].get_sum(m_-i-1, m_-1);
      long long curr = 0;
      for (int j = 0; j < n_; j++) {
        curr += arr_[j].get_sum();
        sub = min(sub, arr_[j].get_sum(m_-i, m_-1));
        int wh = (j+1) * m_ - i;
        ans[wh] = max(ans[wh], curr - sub);
      }
      long long add = 0;
      for (int j = n_-1; j >= 0; j--) {
        curr -= arr_[j].get_sum();
        add = max(add, arr_[j].get_sum(0, i-1));
        int wh = (j * m_ + i);
        ans[wh] = max(ans[wh], curr + add);
      }
    }
    ans.resize(k+1);
    return ans;
  }

  vector<pair<int, long long>> get_reasonable(int k) const {
    vector<pair<int, long long>> res;
    res.reserve(global_pref_.size());
    res.push_back({0, 0});
    int curr = 0;
    for (int i = 0; i < (int) arr_.size(); i++) {
      curr += arr_[i].size();
      if (curr > k) {
        break;
      }
      res.push_back({curr, global_pref_[i+1]});
    }
    return res;
  }

  long long get_opt(int k) const {
    if (k % m_ == 0) {
      return 0;
    }
    if (k > (int) arr_.size() * m_) {
      return 0;
    }
    int req = k / m_;
    int rest = k - req * m_;
    int too_much = m_ - rest;
    long long best = 0;
    for (int i = 0; i < req; i++) {
      long long res = global_pref_[req + 1];
      res -= arr_[i].get_sum(m_-too_much, m_-1);
      best = max(best, res);
    }
    for (int i = req; i < (int) arr_.size(); i++) {
      long long res = global_pref_[req];
      res += arr_[i].get_sum(0, rest-1);
      best = max(best, res);
    }
    return best;
  }

 private:
  int m_;
  int n_;
  vector<SumVector> arr_;
  vector<long long> global_pref_;
};

bool is_increasing(const vector<long long>& vec) {
  for (int i = 0; i < (int) vec.size() - 1; i++) {
    if (vec[i] > vec[i+1]) {
      return false;
    }
  }
  return true;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);

  int n, m, k;
  cin >> n >> m >> k;
  vector<vector<long long>> arr(n, vector<long long>(m));
  for (auto& vec : arr) {
    for (auto& v : vec) {
      cin >> v;
    }
  }

  DecreasingHandler dec_handler(n * m);
  IncreasingHandler inc_handler(n, m);

  for (auto& vec : arr) {
    if (is_increasing(vec)) {
      inc_handler.add_vec(move(vec));
    }
    else {
      dec_handler.add_vec(move(vec));
    }
  }

  dec_handler.init();
  inc_handler.init();

  /* 
  auto reasonable = inc_handler.get_reasonable(k);

  long long best = 0;
  for (auto [cnt, res] : reasonable) {
    best = max(best, res + dec_handler.get_opt(k - cnt));
  }

  auto [cnt, res] = dec_handler.get_all();
  if (cnt <= k) {
    best = max(best, res + inc_handler.get_opt(k - cnt));
  }
  best = max(best, inc_handler(k));
  cout << best << "\n";
  */
  long long best = 0;
  auto inc_good = inc_handler.get_all(k);
  for (int i = 0; i < (int) inc_good.size(); i++) {
//     cerr << i << " " << inc_good[i] << " " <<  dec_handler.get_opt(k-i) << "\n";
    best = max(best, inc_good[i] + dec_handler.get_opt(k - i));
  }
  cout << best << "\n";

}