import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Main {
	public static void main(String[] args) throws NumberFormatException,
	IOException {
		ContestScanner in = new ContestScanner();
		int n = in.nextInt();
		int b = in.nextInt();
		long[][] p = new long[n][3];
		for(int i=0; i<n; i++){
			p[i][0] = in.nextLong();
			p[i][1] = in.nextLong();
			p[i][2] = in.nextLong();
		}
		int res = 0;
		for(int i=0; i<n; i++){
			if(p[i][2] <= b){
				res = 1;
				break;
			}
		}
		Arrays.sort(p, new MyComp1());
		for(int i=0; i<n-1; i++){
			for(int j=i+1; j<n; j++){
				long xmax = Math.max(p[i][0], p[j][0]);
				long xmin = Math.min(p[i][0], p[j][0]);
				int minIdx = 0;
				while(minIdx < n && (p[minIdx][0] < xmin || xmax < p[minIdx][0] || p[minIdx][2] > b)){
					minIdx++;
				}
				if(minIdx >= n) continue;
				int maxIdx = minIdx;
				long nowPoint = p[minIdx][2];
				while(minIdx < n){
					long point = 0;
					int count = 0;
					int max = maxIdx<n?maxIdx:n-1;
					for(int k=minIdx; k<=max; k++){
						if(p[k][0] < xmin || xmax < p[k][0]) continue;
						point += p[k][2];
						count++;
					}
					if(point <= b && count > res){
//						System.out.println("xmax:"+xmax+"\txmin:"+xmin+"\tymax:"+maxIdx+"\tymin:"+minIdx+"\tcount:"+count);
//						if(count == 8)
//							System.out.println(count);
						res = count;
					}
					
					if(maxIdx >= n) break;
					maxIdx++;
					while(maxIdx < n && (p[maxIdx][0] < xmin || xmax < p[maxIdx][0])) maxIdx++;
					if(maxIdx < n) nowPoint += p[maxIdx][2];
					while(maxIdx < n-1 && p[maxIdx][1] == p[maxIdx+1][1]){
						maxIdx++;
						if(p[maxIdx][0] >= xmin && xmax >= p[maxIdx][0]) nowPoint += p[maxIdx][2];
					}
					while(minIdx < maxIdx && nowPoint > b){
						minIdx++;
						if(p[minIdx][0] >= xmin && xmax >= p[minIdx][0]) nowPoint -= p[minIdx][2];
					}
					while(minIdx < n-1 && minIdx > 0 && p[minIdx][1] == p[minIdx-1][1]){
						minIdx++;
						if(p[minIdx][0] >= xmin && xmax >= p[minIdx][0]) nowPoint -= p[minIdx][2];
					}
					
//					if(maxIdx < n-1){
//						do{
//							while(maxIdx < n && (p[maxIdx][0] < xmin || xmax < p[maxIdx][0] || maxIdx == minIdx)){
//								maxIdx++;
//							}
//							if(maxIdx < n) nowPoint += p[maxIdx][2];
//						}while(maxIdx < n-1 && p[maxIdx][1] == p[maxIdx+1][1]);
//					}else if(nowPoint <= b) break;
//					minIdx++;
//					while(minIdx < maxIdx && (nowPoint > b || (minIdx < n-1 && p[minIdx][1] == p[minIdx+1][1]))){
//						minIdx++;
//						if(p[minIdx][0] < xmin || xmax < p[minIdx][0]) continue;
//						nowPoint -= p[minIdx][2];
//					}
				}
			}
		}
		System.out.println(res);
	}
}

class MyComp0 implements Comparator<int[]> {
	public int compare(int[] a, int[] b) {
		return a[0] - b[0];
	}
}

class MyComp1 implements Comparator<long[]> {
	public int compare(long[] a, long[] b) {
		return Long.compare(a[1], b[1]);
	}
}

class Reverse implements Comparator<Integer> {
	public int compare(Integer arg0, Integer arg1) {
		return arg1 - arg0;
	}
}

class Node {
	int id;
	List<Node> edge = new ArrayList<Node>();

	public Node(int id) {
		this.id = id;
	}

	public void createEdge(Node node) {
		edge.add(node);
	}
}

class ContestWriter {
	private PrintWriter out;

	public ContestWriter(String filename) throws IOException {
		out = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
	}

	public ContestWriter() throws IOException {
		out = new PrintWriter(System.out);
	}

	public void println(String str) {
		out.println(str);
	}

	public void print(String str) {
		out.print(str);
	}

	public void close() {
		out.close();
	}
}

class ContestScanner {
	private BufferedReader reader;
	private String[] line;
	private int idx;

	public ContestScanner() throws FileNotFoundException {
		reader = new BufferedReader(new InputStreamReader(System.in));
	}

	public ContestScanner(String filename) throws FileNotFoundException {
		reader = new BufferedReader(new InputStreamReader(new FileInputStream(
				filename)));
	}

	public String nextToken() throws IOException {
		if (line == null || line.length <= idx) {
			line = reader.readLine().trim().split(" ");
			idx = 0;
		}
		return line[idx++];
	}

	public long nextLong() throws IOException, NumberFormatException {
		return Long.parseLong(nextToken());
	}

	public int nextInt() throws NumberFormatException, IOException {
		return (int) nextLong();
	}

	public double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextToken());
	}
}