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

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

struct Stacks {
	const int n;
	const int m;
	const int k;
	const map<long long, vector<vector<long long>>> stackMap;
	const vector<long long> descendingSingleValues;
	const vector<long long> mapKeysVector;
	const int F;

	long long resultValue = 0;
	int freeSpace = 0;

	Stacks(int n, int m, int k,
			const map<long long, vector<vector<long long>>> &stackMap,
			const vector<long long> &descendingValues) :
			n(n), m(m), k(k), stackMap(stackMap), descendingSingleValues(
					descendingValues), mapKeysVector([&]() {
				vector<long long> keys;
				keys.reserve(stackMap.size());
				for (auto it = stackMap.rbegin(); it != stackMap.rend(); ++it) {
					keys.push_back(it->first);
				}
				return keys;
			}()), F(descendingSingleValues.size()) {
	}

	void process() {
		if (stackMap.size() > 0) {
			processWithMap();
		} else {
			resultValue = 0;
			for (int i = 0; i < k; i++) {
				resultValue += descendingSingleValues[i];
			}
		}
	}
	void processWithMap() {
		resultValue = 0;
		freeSpace = k;

		int singleIndex = 0;
		unsigned int stacksIndex = 0;

		while (freeSpace > 0) {
			const long long int stackKeyValue =
					stacksIndex >= mapKeysVector.size() ?
							0 : mapKeysVector[stacksIndex];
			if (freeSpace == m) {
				fillTail(stacksIndex, singleIndex);
				break;
			} else if (singleIndex < F
					&& descendingSingleValues[singleIndex] * m
							> stackKeyValue) {
				resultValue += descendingSingleValues[singleIndex];
				freeSpace--;
				singleIndex++;
			} else {
				int stacksCount = stackMap.at(stackKeyValue).size();
				const int multiplier = min(freeSpace / m, stacksCount);
				if (multiplier > 0) {
					stacksCount -= multiplier;
					resultValue += multiplier * stackKeyValue;
					freeSpace -= multiplier * m;
				}
				if (freeSpace >= m) {
					stacksIndex++;
				} else {
					if (stacksCount == 0) {
						fillTail(stacksIndex + 1, singleIndex);
					} else {
						fillTail(stacksIndex, singleIndex);
					}
					break;
				}
			}
		}

	}

	void fillTail(int stacksIndex, int singleIndex) {
		vector<long long> maxStackSubSum(m + 1, 0);
		const int K = mapKeysVector.size();
		long long int partialSum = 0;
		for (int i = stacksIndex; i < K; i++) {
			const long long int stackKeyValue = mapKeysVector[stacksIndex];
			const vector<vector<long long>> &stacks = stackMap.at(
					stackKeyValue);
			for (const vector<long long> &stackVector : stacks) {
				partialSum = 0;
				for (int j = 1; j <= m; j++) {
					partialSum += stackVector[j - 1];
					if (partialSum > maxStackSubSum[j]) {
						maxStackSubSum[j] = partialSum;
					}
				}
			}
		}

		const int maxSingleLength = min(F - singleIndex, freeSpace);
		vector<long long> maxSingleSubSum(maxSingleLength + 1, 0);
		partialSum = 0;
		for (int j = 0; j < maxSingleLength; j++) {
			partialSum += descendingSingleValues[singleIndex + j];
			maxSingleSubSum[j + 1] = partialSum;
		}

		long long int maxTail = 0;
		for (int i = 0; i <= maxSingleLength; i++) {
			const long long int current = maxSingleSubSum[i]
					+ maxStackSubSum[freeSpace - i];
			if (current > maxTail) {
				maxTail = current;
			}
		}
		resultValue += maxTail;
		freeSpace = 0;
	}
};

struct Node {
	long long last;
	long long secondLast;
	int index;

	bool operator<(const Node &other) const {
		if (last != other.last)
			return last > other.last; // min-heap behavior
		return secondLast > other.secondLast;
	}
};

void removeLowest(vector<vector<long long>> &stacks, int kk) {
	priority_queue<Node> pq;

	for (int i = 0; i < (int) stacks.size(); ++i) {
		if (!stacks[i].empty()) {
			long long last = stacks[i].back();
			long long secondLast =
					(stacks[i].size() >= 2) ?
							stacks[i][stacks[i].size() - 2] : (long long) 1e18; // treat missing as very large

			pq.push( { last, secondLast, i });
		}
	}

	while (kk-- > 0 && !pq.empty()) {
		Node top = pq.top();
		pq.pop();

		int i = top.index;

		stacks[i].pop_back();

		if (!stacks[i].empty()) {
			long long last = stacks[i].back();
			long long secondLast =
					(stacks[i].size() >= 2) ?
							stacks[i][stacks[i].size() - 2] : (long long) 1e18;

			pq.push( { last, secondLast, i });
		}
	}
}

long long sumStacks(const vector<vector<long long>> &stacks) {
	long long total = 0;

	for (const auto &vec : stacks) {
		for (long long x : vec) {
			total += x;
		}
	}

	return total;
}

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

	int n, m, k;
	map<long long int, vector<vector<long long int>>> stackMap;
	vector<long long int> descendingValues;
	long long int a;
	cin >> n;
	cin >> m;
	cin >> k;
	vector<vector<long long int>> stacks(n);

	long long int shortMax = 0;
	bool c = k <= m;
	for (int i = 0; i < n; i++) {
		vector<long long int> stack(m);
		long long int stackValue = 0;
		for (int j = 1; j <= m; j++) {
			cin >> a;
			stack[j - 1] = a;
			stackValue += a;
			if (c && j == k && stackValue > shortMax) {
				shortMax = stackValue;
			}
		}
		stacks[i] = stack;
		if (isAscending(stack)) {
			stackMap[stackValue].push_back(stack);
		} else {
			descendingValues.insert(descendingValues.end(),
					make_move_iterator(stack.begin()),
					make_move_iterator(stack.end()));
		}
	}
	sort(descendingValues.begin(), descendingValues.end(), greater<int>());

	Stacks s(n, m, k, stackMap, descendingValues);
	s.process();

	removeLowest(stacks, m * n - k);
	long long int sum = sumStacks(stacks);
	long long int r = max(sum, max(shortMax, s.resultValue));

	cout << r << endl;
}