#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

long maximize(int x_rows, int x_columns, vector<vector<int>>& x) {
    vector<vector<long>> prefixSum(x_rows + 1, vector<long>(x_columns + 1, 0));
    for (int i = 1; i <= x_rows; ++i) {
        for (int j = 1; j <= x_columns; ++j) {
            prefixSum[i][j] = x[i-1][j-1] + 
                               prefixSum[i-1][j] + 
                               prefixSum[i][j-1] - 
                               prefixSum[i-1][j-1];
        }
    }

    long maxF = 0; 

    for (int h = 1; h < x_rows; ++h) {
        for (int v = 1; v < x_columns; ++v) {
            long sumA = prefixSum[h][v]; 
            long sumB = prefixSum[h][x_columns] - prefixSum[h][v];
            long sumC = prefixSum[x_rows][v] - prefixSum[h][v]; 
            long sumD = prefixSum[x_rows][x_columns] - prefixSum[h][x_columns] - prefixSum[x_rows][v] + prefixSum[h][v]; // Bottom-right
            long fX = abs(sumA) + abs(sumB) + abs(sumC) + abs(sumD);
            maxF = max(maxF, fX);
        }
    }

    return maxF;
}

def ss(firstnum: str, secondnum: str, thirdnum: str) -> bool:
    target_sum = int(thirdnum)
    second_value = int(secondnum)
    if int(firstnum) + second_value == target_sum:
        return True
    for i in range(len(firstnum)):
        new_firstnum = firstnum[:i] + firstnum[i+1:]
        if new_firstnum and (new_firstnum[0] != '0'): 
            if int(new_firstnum) + second_value == target_sum:
                return True
    return False

import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] arr = new int[N];
        for(int i=0;i<N;i++) arr[i] = sc.nextInt();
        int k = sc.nextInt();
        Arrays.sort(arr);
        int left=0, right=N-1, moves=0;
        while(left <= right){
            if(arr[left] + arr[right] <=k) left++;
            right--;
            moves++;
        }
        System.out.println(moves);
    }
}

import java.util.*;
import java.io.*;

public class Main {
    static class Segment {
        int L;
        int R;
        int cost;
        Segment(int L, int R, int cost){
            this.L = L;
            this.R = R;
            this.cost = cost;
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        sc.nextInt(); // Read the '3' and ignore
        Segment[] segments = new Segment[N];
        for(int i=0;i<N;i++) {
            int L = sc.nextInt();
            int R = sc.nextInt();
            int cost = sc.nextInt();
            segments[i] = new Segment(L, R, cost);
        }
        Segment[] sortedByL = segments.clone();
        Arrays.sort(sortedByL, new Comparator<Segment>() {
            public int compare(Segment a, Segment b){
                if(a.L != b.L) return Integer.compare(a.L, b.L);
                return Integer.compare(a.R, b.R);
            }
        });
        Segment[] sortedByR = segments.clone();
        Arrays.sort(sortedByR, new Comparator<Segment>() {
            public int compare(Segment a, Segment b){
                if(a.R != b.R) return Integer.compare(a.R, b.R);
                return Integer.compare(a.L, b.L);
            }
        });
        long minCost = Long.MAX_VALUE;
        long minProduct = Long.MAX_VALUE;
        int r_ptr = 0;
        for(int i=0;i<N;i++) {
            Segment current = sortedByL[i];
            while(r_ptr < N && sortedByR[r_ptr].R < current.L){
                if(sortedByR[r_ptr].cost < minCost){
                    minCost = sortedByR[r_ptr].cost;
                }
                r_ptr++;
            }
            if(minCost != Long.MAX_VALUE){
                long product = minCost * (long)current.cost;
                if(product < minProduct){
                    minProduct = product;
                }
            }
        }
        if(minProduct != Long.MAX_VALUE){
            System.out.println(minProduct);
        }
        else{
            System.out.println(-1);
        }
    }
}

def solution(S):
    r={'AB','BA','CD','DC'}
    s=[]
    for c in S:
        if s and s[-1]+c in r:
            s.pop()
        else:
            s.append(c)
    return ''.join(s)