//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define all(x) std::begin(x), std::end(x)
#define isz(x) (int)std::size(x)
const auto io_sync_off = [](){std::ios_base::sync_with_stdio(0);std::cin.tie(0);return 0;}();
// Debug defines:
#define watch(x) std::cerr << std::setw(12) << #x << " = " << std::setw(12) << x
#define watchln(x) watch(x) << std::endl
#define watchsp(x) watch(x) << " "
#define cerr cerr && debug && std::cerr
const int debug = 0;
namespace std {
    // Vector:
    template<typename T> auto size(const std::vector<T>& vec) { return vec.size(); }
    template<typename T> auto begin(const std::vector<T>& vec) { return vec.begin(); }
    template<typename T> auto end(const std::vector<T>& vec) { return vec.end(); }
    // 2D arrays:
    template<typename T, int N, int M> auto size(const T (&a)[N][M]) { return N * M; }
    template<typename T, int N, int M> auto begin(T (&a)[N][M]) { return &a[0][0]; }
    template<typename T, int N, int M> auto end(T (&a)[N][M]) { return &a[0][0] + N * M; }
    // 3D arrays:
    template<typename T, int N, int M, int K> auto size(const T (&a)[N][M][K]) { return N * M * K; }
    template<typename T, int N, int M, int K> auto begin(T (&a)[N][M][K]) { return &a[0][0][0]; }
    template<typename T, int N, int M, int K> auto end(T (&a)[N][M][K]) { return &a[0][0][0] + N * M * K; }
    // Algorithms:
    template<typename C> void reuniq(C& c) { c.erase(unique(all(c)), end(c)); }
    template<typename C, typename X> int lowpos(C& c, X& x) {
        return int(lower_bound(all(c), x) - begin(c));
    }
    template<typename X, typename Y> X& remin(X& x, const Y& y) { return x = (y < x) ? y : x; }
    template<typename X, typename Y> X& remax(X& x, const Y& y) { return x = (x < y) ? y : x; }
}
// Comparators:
template<typename A, typename B> bool operator >(const A& a, const B& b) { return b < a; }
template<typename A, typename B> bool operator<=(const A& a, const B& b) { return !(a > b); }
template<typename A, typename B> bool operator>=(const A& a, const B& b) { return !(a < b); }
template<typename A, typename B> bool operator!=(const A& a, const B& b) { return a < b || b < a; }
template<typename A, typename B> bool operator==(const A& a, const B& b) { return !(a != b); }
// Input:
template<typename T> std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
    for (auto &it : vec) is >> it;
    return is;
}
// Output:
template<typename A, typename B> std::ostream& operator<<(std::ostream& os, const std::pair<A,B>& pt) {
    return os << "{" << pt.first << ", " << pt.second << "}";
}
template<typename T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
    os << "{";
    for (int i = 0; i < isz(vec); i++) {
        if (i > 0) os << ", ";
        os << vec[i];
    }
    return os << "}";
}
template<typename T> std::ostream& operator<<(std::ostream& os, const std::set<T>& vec) {
    os << "{";
    for (auto it = vec.begin(); it != vec.end(); it++) {
        if (it != vec.begin()) { os << ", "; }
        os << *it;
    }
    return os << "}";
}
// Defines:
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = std::vector<int>;
using vl = std::vector<ll>;
using vvi = std::vector<vi>;
using vvl = std::vector<vl>;
using pii = std::pair<int,int>;
using pil = std::pair<int,ll>;
using pli = std::pair<ll,int>;
using pll = std::pair<ll,ll>;
// -----------------------------------------------------------------------------
struct PrefSum {
    vl s;
    PrefSum(vl a) {
        s.assign(isz(a) + 1, 0);
        for (int i = 0; i < isz(a); i++) {
            s[i+1] = s[i] + a[i];
        }
    }
    ll operator()(ll i, ll j) const {
        assert(0 <= i && i <= j && j+1 < isz(s));
        return s[j+1] - s[i];
    }
};
int main() {
    // solution
    ll n, m, v, p;
    while (std::cin >> n >> m >> v >> p) {
        vl a(n); std::cin >> a;
        std::sort(all(a),std::greater<>());
        PrefSum s(a);
        ll i = p;
        while (i < n && a[i-1] == a[i]) i++;
        watchln("------------------");
        watchln(a);
        watchln(i);
        while (i < n) {
            ll val = a[i] + m;
            ll total = v * m;
            total -= (n - i) * m;
            total -= (p - 1) * m;
            // sum on [p-1, ..., i-1]
            ll sum = s(p-1,i-1);
            total -= val * ((i-1) - (p-1) + 1) - sum;
            if (a[p-1] > val || total > 0) {
                break;
            }
            i++;
        }
        std::cout << i << std::endl;
    }
    return 0;
}

Measured memory_bytes: 2560