#include <iostream>
#include <vector>
#include <cstdio>
#include <sstream>
#include <map>
#include <string>
#include <algorithm>
#include <queue>
#include <cmath>
#include <functional>
#include <set>
#include <ctime>
#include <random>
#include <cassert>
using namespace std;
template<class T> istream& operator >> (istream& is, vector<T>& vec){for(T& val: vec) is >> val; return is;}
template<class T> istream& operator , (istream& is, T& val){ return is >> val;}
template<class T> ostream& operator << (ostream& os, vector<T>& vec){for(int i=0; i<vec.size(); i++) os << vec[i] << (i==vec.size()-1?"\n":" ");return os;}
template<class T> ostream& operator , (ostream& os, T& val){ return os << " " << val;}
template<class T> ostream& operator >> (ostream& os, T& val){ return os << " " << val;}
bool is_kadomatsu_sequence(vector<int> x){
    if(x.size() != 3) return false;
    if(x[0] < x[1] && x[1] > x[2] && x[2] != x[0]) return true;
    if(x[0] > x[1] && x[1] < x[2] && x[2] != x[0]) return true;
    return false;
}

template<class T=int>
class SparseTable{
	int col;
	int row;
	T default_value;
	vector<T>* values;

	vector<vector<T>> table;


	static T default_evaluate(T a, T b){
		return min(a,b);
	}

	function<T(T,T)> evaluate;

public:
	SparseTable(int len, T default_value_ = 100000000, function<T(T,T)> eval = default_evaluate) : col(len), default_value(default_value_) {
		evaluate = eval;
		row = 1;
		while((1<<row) < col) row += 1;
		row++;
		table = vector<vector<T>>(row, vector<T>(col, default_value));
	}

	SparseTable(vector<T>& vec, T default_value_ = 100000000, function<T(T,T)> eval = default_evaluate) : col(vec.size()), default_value(default_value_){
		evaluate = eval;

		row = 1;
		while((1<<row) < col) row += 1;
		row++;
		table = vector<vector<T>>(row, vector<T>(col, default_value));

		set(vec);
	}


	void set(vector<T>& vec){
		assert(col == vec.size());

		values = &vec;
		vector<T>& val = vec;

		iota(table[0].begin(), table[0].end(), 0);
		for(int k=1; k<row; k++){
			for(int i=0; i + (1<<k)-1 < col; i++){
				T left = val[table[k-1][i]];
				T right = val[table[k-1][i+(1<<(k-1))]];
				if(left == evaluate(left,right)){
					table[k][i] = table[k-1][i];
				}else{
					table[k][i] = table[k-1][i+(1<<(k-1))];
				}
			}
		}
	}

	//[l,r)
	T get(int l, int r){
		if(l>=r) return default_value;
		vector<T>& val = *values;

		T ret = default_value;

		int k = 0;
		while((1<<(k+1)) < (r-l)) k++;

		T left = val[ table[k][l] ];
		T right = val[ table[k][r-(1<<k)] ];

		ret = evaluate(left, right);
		return ret;
	}
};


int main(){
	int n,m;
	cin >> n,m;
	vector<vector<int>> a(m, vector<int>(n));
	//cin >> a;
	for(int i=0; i<m; i++){
		for(int j=0; j<n; j++){
			scanf("%d", &a[i][j]);
		}
	}
	function<int(int,int)> my_min = [&](int l, int r){return min(l,r);};
	function<int(int,int)> my_max = [&](int l, int r){return max(l,r);};

	long long max_ = 0;

	int val = 0;
	for(int i=0; i<m; i++){
		SparseTable<int> st_min(a[i], 2000, my_min);
		SparseTable<int> st_max(a[i], -1, my_max);

		long long sum = 0;

		for(int x=0; x<n; x++){
			for(int y=x+1; y<n; y++){
				int ans = 0;

				int l = a[i][x];
				int r = a[i][y];
				if(l<r){ // z > l < r
					if(x>0){
						int z = st_max.get(0,x);
						if(z > l){
							int hoge = max(z, r);

							if(ans<hoge){
								ans = hoge;
							}

						}
					}
				}else{ // z < l > r
					if(x>0){
						int z = st_min.get(0,x);
						if(z < l){
							int hoge = l;

							if(ans<hoge){
								ans = hoge;
							}

						}
					}
				}

				if(r-l > 1){
					// l < z > r
					int z = st_max.get(l+1, r);
					if(z > max(l,r)){
						int hoge = z;

						if(ans<hoge){
							ans = hoge;
						}

					}
					// l > z < r
					z = st_min.get(l+1, r);
					if(z < min(l,r)){
						int hoge = max(l,r);

						if(ans<hoge){
							ans = hoge;
						}
					}
				}

				if(l<r){ // l < r > z
					if(n-r > 1){
						int z = st_min.get(r+1, n);
						if(z < r){
							int hoge = r;

							if(ans<hoge){
								ans = hoge;
							}

						}
					}
				}else{ // l > r < z
					if(n-r > 1){
						int z = st_max.get(r+1, n);
						if(z > r){
							int hoge = max(l,z);

							if(ans<hoge){
								ans = hoge;
							}

						}
					}

				}

				sum += ans;
			}
		}

		if(max_ < sum){
			max_ = sum;
			val = i;
		}
	}

	cout << val << endl;

	return 0;
}