#include"bits/stdc++.h"
using namespace std;
#define LL long long
#define PB push_back
#define MP make_pair

//RMQ
struct SegmentTree{
private:
	int N;
	vector<long long> node, lazy;
	vector<bool> lazyFlg;
	const long long DEFAULT = 0LL;
public:
	void init(int n){ //初期化 O(N)
		node.clear();
		lazy.clear();
		lazyFlg.clear();
		N = 1;
		while(N < n) N = (N<<1);
		for(int i=0; i<2*N-1; i++){
			node.push_back(DEFAULT);
			lazy.push_back(0LL);
			lazyFlg.push_back(false);
		}
	}
	void eval(int k, int l, int r){ //遅延評価 O(1)
		if(lazyFlg[k]){ //RUQ：下に更新クエリが溜まっていても加算クエリが溜まっていても上書き
			node[k] = lazy[k];
			if(r-l > 1){
				lazy[2*k+1] = lazy[k];
				lazyFlg[2*k+1] = true;
				lazy[2*k+2] = lazy[k];
				lazyFlg[2*k+2] = true;
			}
			lazy[k] = 0LL;
			lazyFlg[k] = false;
		}
		else{ //RAQ：下に更新クエリが溜まっていても加算クエリが溜まっていても加算
			node[k] += lazy[k];
			if(r-l > 1){
				lazy[2*k+1] += lazy[k];
				lazy[2*k+2] += lazy[k];
			}
			lazy[k] = 0LL;
		}
	}
	void update(int a, long long x){ //[a,a+1)の値を変更 O(log N)
		update(a, a+1, x);
	}
	void update(int a, int b, long long x, int k=0, int l=0, int r=-1){ //[a,b)の値を変更 O(log N)
		if(r == -1) r = N;
		eval(k, l, r);
		if(b <= l || r <= a) return; //交差する場合
		if(a <= l && r <= b){ //完全に含む場合
			lazy[k] = x;
			lazyFlg[k] = true;
			eval(k, l, r);
		}
		else{
			update(a, b, x, 2*k+1, l, (l+r)/2);
			update(a, b, x, 2*k+2, (l+r)/2, r);
			node[k] = std::max(node[2*k+1], node[2*k+2]);
		}
	}
	void add(int a, long long x){ //[a,a+1)の値に加算 O(log N)
		add(a, a+1, x);
	}
	void add(int a, int b, long long x, int k=0, int l=0, int r=-1){ //[a,b)の値に加算 O(log N)
		if(r == -1) r = N;
		eval(k, l, r);
		if(b <= l || r <= a) return; //交差する場合
		if(a <= l && r <= b){ //完全に含む場合
			lazy[k] += x;
			eval(k, l, r);
		}
		else{
			add(a, b, x, 2*k+1, l, (l+r)/2);
			add(a, b, x, 2*k+2, (l+r)/2, r);
			node[k] = std::max(node[2*k+1], node[2*k+2]);
		}
	}
	long long max(int a, int b, int k=0, int l=0, int r=-1){ //[a,b)の最大値 O(log N)
		if(r == -1) r = N;
		if(b <= l || r <= a) return DEFAULT; //交差する場合
		eval(k, l, r);
		if(a <= l && r <= b) return node[k]; //完全に含む場合
		return std::max(max(a, b, k*2+1, l, (l+r)/2), max(a, b, k*2+2, (l+r)/2, r));
	}
	long long m;
	int find(int a, int b, int k=0, int l=0, int r=-1){ //[a,b)の最小値の場所 O(log N)
		if(r == -1){
			m = max(a, b);
			r = N;
		}
		if(r <= a || b <= l) return INT_MAX; //交差する場合
		if(r-l == 1){
			if(node[k] == m) return l;
			else return INT_MAX;
		}
		if(a <= l && r <= b){ //完全に含む場合
			int valueL = max(a, b, k*2+1, l, (l+r)/2);
			int valueR = max(a, b, k*2+2, (l+r)/2, r);
			if(valueL == m) return find(a, b, k*2+1, l, (l+r)/2);
			if(valueR == m) return find(a, b, k*2+2, (l+r)/2, r);
			return INT_MAX;
		}
		return std::min(find(a, b, k*2+1, l, (l+r)/2), find(a, b, k*2+2, (l+r)/2, r));
	}
};

LL N, R, L, d[1000000], t[1000000], x[1000000];
SegmentTree st;
LL ans[100000] ={};
int main(){
	cin >> N >> R >> L;
	for(int i=0; i<R; i++){
		scanf("%lld%lld%lld", &d[i], &t[i], &x[i]);
		d[i]--;
	}
	st.init(N);
	
	for(int i=0; i<R; i++){
		ans[st.find(0, N)] += t[i] - (i != 0 ? t[i-1] : 0);
		st.add(d[i], x[i]);
	}
	ans[st.find(0, N)] += L - t[R-1];

	int idx = -1;
	LL m = -1;
	for(int i=0; i<N; i++){
		if(m < ans[i]){
			idx = i;
			m = ans[i];
		}
	}
	cout << idx+1 << endl;
}


Measured memory_bytes: 22588