#include <fstream>
#include <algorithm>
#include <bitset>
#define NMAX 700
using namespace std;

int M, N, R, C, MAX, total;
int mat[NMAX][NMAX];
int sum_row[NMAX], sum_col[NMAX];
bitset<7295> sol;

void input() {
	ifstream in("elimin.in");
	in>>M>>N>>R>>C;

	if (M < N) {
		for (int i = 0; i < M; ++i) {
			for (int j = 0; j < N; ++j) {
				in>>mat[i][j];
			}
    }
  } else {
			for (int i = 0; i < M; ++i) {
				for (int j = 0; j < N; ++j) {
					in>>mat[j][i];
				}
			}

			swap(M, N); swap(R, C);
	}
	for (int i = 0; i < M; ++i) {
    int sum = 0;
    for (int j = 0; j < N; ++j) {
      sum += mat[i][j];
    }
    total += sum;
    sum_row[i] = sum;
	}
	in.close();
}

void sortescu(int total) {
  int i, j;
  for (i = 0; i < N; ++i) {
    sum_col[i] = 0;
  }
  for (i = 0; i < M; ++i) {
    if (!sol[i]) {
      for (j = 0; j < N; ++j) {
        sum_col[j] += mat[i][j];
      }
    }
  }

  sort(sum_col, sum_col + N);
  for (i = 0; i < C && total > MAX; ++i) {
    total -= sum_col[i];
  }
  if (total > MAX) {
    MAX = total;
  }
}

void linii() {
  if (!R) {
    sortescu(total);
    return;
  }
  int size = 1 << M;
  for (int i = 0; i < size; ++i) {
    int j, local = total, count = 0;
    for (j = 0; j < M && count < R; ++j) {
      if ((i & (1 << j)) && (local - sum_row[j] > MAX)) {
        sol[j] = 1, local -= sum_row[j];
        ++count;
      } else {
        sol[j] = 0;
      }
    }
    if ((count == R) && ((i >> j) == 0)) {
      sortescu(local);
    }
  }
}

inline void output() {
  ofstream out("elimin.out");
  out<<MAX;
  out.close();
}

int main() {
  input();
  linii();
  output();
  return 0;
}

/*int MAX;
vector<vector<int> > mat;
vector<int> sum_row, sum_col;

void input(int &M, int &N, int &R, int &C, int &total) {
  ifstream in("elimin.in");
  in>>M>>N>>R>>C;
  sum_row.resize(M);
  sum_col.resize(N);
  vector<int> row(N, 0);
  for (int i = 0; i < M; ++i) {
    mat.push_back(row);
    int val, sum = 0;
    for (int j = 0; j < N; ++j) {
      in>>val;
      mat[i][j] = val;
      sum += val;
      sum_col[j] += val;
    }
    total += sum;
    sum_row[i] = sum;
  }
  in.close();
}

void columnSort(int &M, int &N, int &C, int total, bitset<7295> &sol) {
  int i, j;
  for (i = 0; i < N; ++i) {
    sum_col[i] = 0;
  }
  for (i = 0; i < M; ++i) {
    if (!sol[i]) {
      for (j = 0; j < N; ++j) {
        sum_col[j] += mat[i][j];
      }
    }
  }

  sort(sum_col.begin(), sum_col.end());
  for (i = 0; i < C && total > MAX; ++i) {
    total -= sum_col[i];
  }
  if (total > MAX) {
    MAX = total;
  }
}

void rowSort(int &M, int &N, int &R, int total, bitset<7295> &sol) {
  int i, j;
  for (i = 0; i < M; ++i) {
    int sum = 0;
    for (j = 0; j < N; ++j) {
      if (!sol[j]) {
        sum += mat[i][j];
      }
    }
    sum_row[i] = sum;
  }
  sort(sum_row.begin(), sum_row.end());
  for (i = 0; i < R && total > MAX; ++i) {
    total -= sum_row[i];
  }
  if (total > MAX) {
    MAX = total;
  }
}

void linii(int &M, int &N, int &R, int &C, int &total, bitset<7295> &sol) {
  if (!R) {
    columnSort(M, N, C, total, sol);
    return;
  }
  int size = 1 << M;
  for (int i = 0; i < size; ++i) {
    int j, local = total, count = 0;
    for (j = 0; j < M && count < R; ++j) {
      if ((i & (1 << j)) && (local - sum_row[j] > MAX)) {
        sol[j] = 1, local -= sum_row[j];
        ++count;
      } else {
        sol[j] = 0;
      }
    }
    if ((count == R) && ((i >> j) == 0)) {
      columnSort(M, N, C, local, sol);
    }
  }
}

void coloane(int &M, int &N, int &R, int &C, int &total, bitset<7295> &sol) {
  if (!C) {
    rowSort(M, N, R, total, sol);
    return;
  }
  int size = 1 << N;
  for (int i = 0; i < size; ++i) {
    int j, local = total, count = 0;
    for (j = 0; j < N && count < C; ++j) {
      if ((i & (1 << j)) && (local - sum_col[j] > MAX)) {
        sol[j] = 1, local -= sum_col[j];
        ++count;
      } else {
        sol[j] = 0;
      }
    }
    if ((count == C) && ((i >> j) == 0)) {
      rowSort(M, N, R, local, sol);
    }
  }
}

inline void output() {
  ofstream out("elimin.out");
  out<<MAX;
  out.close();
}

int main() {
  int M, N, R, C, total;
  bitset<7295> sol;
  input(M, N, R, C, total);
  if (M <= N) {
    linii(M, N, R, C, total, sol);
  } else {
    coloane(M, N, R, C, total, sol);
  }
  output();
  return 0;
}*/