#include <iostream>
#include <vector>
#include <climits>
#include <algorithm>
#include <cstdio>

using namespace std;

class OmijaczTatyBajtkaIO {
public:
    long long zwin_liczbe_niepostrzezenie() {
        char c = capnij_znak();
       while (c <= 32) {
            if (c == EOF) return -1;
            c = capnij_znak();
        }
        long long res = 0;
        while (c > 32) {
            res = res * 10 + (c - '0');
            c = capnij_znak();
        }
        return res;
    }
private:
    static const int BUF_SIZE = 1 << 16;
    char buf[BUF_SIZE];
    int buf_pos = 0;
    int buf_len = 0;

    char capnij_znak() {
        if (buf_pos == buf_len) {
            buf_pos = 0;
            buf_len = fread(buf, 1, BUF_SIZE, stdin);
            if (buf_len == 0) return EOF;
        }
        return buf[buf_pos++];
    }
};

template <typename T>
class TalerzBezBalaganu {
private:
    int cols;
    vector<T> data;

public:
    TalerzBezBalaganu(int rows, int cols, T default_value = 0)
       : cols(cols), data(rows * cols, default_value) {}

    inline T& operator()(int r, int c) {
        return data[r * cols + c];
    }

    inline const T& operator()(int r, int c) const {
        return data[r * cols + c];
    }
};

struct OszukanaWieza {
    long long total_sum;
    int flat_id;
};

class IleOwaliNalesnikow {
public:
    IleOwaliNalesnikow(int n, int m, long long k)
        : total_stacks(n), stack_height(m), max_allowed_eaten(k),
          b_prefixes(n, m + 1, 0)
    {
        descending_pool.reserve(n * m);
        ascending_stacks.reserve(n);
    }

    void dorzuc_wieze_od_taty(const vector<long long>& current_stack) {
        long long current_sum = 0;
        for (long long pancake : current_stack) {
            current_sum += pancake;
        }

        if (current_stack[0] >= current_stack[stack_height - 1]) {
            for (long long pancake : current_stack) {
                descending_pool.push_back(pancake);
            }
        }
        else {
            int stack_id = current_b_count++;
            ascending_stacks.push_back({current_sum, stack_id});

            long long prefix_sum = 0;
            for (int j = 0; j < stack_height; ++j) {
                prefix_sum += current_stack[j];
                b_prefixes(stack_id, j + 1) = prefix_sum;
            }
        }
    }

    long long odpal_wielkie_zarcie() {
 sort(descending_pool.rbegin(), descending_pool.rend());
        vector<long long> pref_A(descending_pool.size() + 1, 0);
        for (size_t i = 0; i < descending_pool.size(); ++i) {
            pref_A[i + 1] = pref_A[i] + descending_pool[i];
        }

        sort(ascending_stacks.begin(), ascending_stacks.end(), [](const OszukanaWieza& x, const OszukanaWieza& y) {
            return x.total_sum > y.total_sum;
        });

        int S = ascending_stacks.size();
        vector<long long> pref_B_sums(S + 1, 0);
        for (int i = 0; i < S; ++i) {
            pref_B_sums[i + 1] = pref_B_sums[i] + ascending_stacks[i].total_sum;
        }

        TalerzBezBalaganu<long long> max_pref_not_top(S + 1, stack_height, 0);
        TalerzBezBalaganu<long long> min_suffix_top(S + 1, stack_height, INT_MAX);

        for (int p = 1; p < stack_height; ++p) {
            for (int c = S - 1; c >= 0; --c) {
                long long val = b_prefixes(ascending_stacks[c].flat_id, p);
                max_pref_not_top(c, p) = max(max_pref_not_top(c + 1, p), val);
            }
        }

        for (int p = 1; p < stack_height; ++p) {
            for (int c = 1; c <= S; ++c) {
                long long suffix = ascending_stacks[c - 1].total_sum - b_prefixes(ascending_stacks[c - 1].flat_id, p);
                min_suffix_top(c, p) = min(min_suffix_top(c - 1, p), suffix);
            }
        }

        long long max_pancakes_size = 0;

        for (int c = 0; c <= S; ++c) {
            long long rem = max_allowed_eaten - 1LL * c * stack_height;
            if (rem >= 0 && rem <= (long long)descending_pool.size()) {
                max_pancakes_size = max(max_pancakes_size, pref_B_sums[c] + pref_A[rem]);
            }
        }

        for (int c = 0; c <= S; ++c) {
            for (int p = 1; p < stack_height; ++p) {
                long long rem = max_allowed_eaten - 1LL * c * stack_height - p;
                if (rem < 0 || rem > (long long)descending_pool.size()) continue;

                long long  score_A = pref_A[rem];

                long long score_B = -1;

                if (c < S) {
                    score_B = max(score_B, pref_B_sums[c] + max_pref_not_top(c, p));
                }
                if (c > 0 && c <= S) {
                    score_B = max(score_B, pref_B_sums[c] - min_suffix_top(c, p));
                }

                if (score_B != -1) {
                    max_pancakes_size = max(max_pancakes_size, score_A + score_B);
                }
            }
        }

        return max_pancakes_size;
    }

private:
    int total_stacks, stack_height;
    long long max_allowed_eaten;

    vector<long long> descending_pool;
    vector<OszukanaWieza> ascending_stacks;
    TalerzBezBalaganu<long long> b_prefixes;

    int current_b_count = 0;
};

int main() {
    OmijaczTatyBajtkaIO scanner;

    long long n = scanner.zwin_liczbe_niepostrzezenie();
    if (n == -1) return 0;

    long long m = scanner.zwin_liczbe_niepostrzezenie();
    long long k = scanner.zwin_liczbe_niepostrzezenie();

    IleOwaliNalesnikow solver(n, m, k);
    vector<long long> current_stack(m);

    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {

            current_stack[j] = scanner.zwin_liczbe_niepostrzezenie();
        }
        solver.dorzuc_wieze_od_taty(current_stack);
    }

    cout << solver.odpal_wielkie_zarcie() << endl;

    return 0;
}