#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
  stringstream ss;
  if (p >= 0) ss << fixed << setprecision(p);
  ss << a;
  T r;
  ss >> r;
  return r;
}
template <class T>
void db(T a, int p = -1) {
  if (p >= 0) cout << fixed << setprecision(p);
  cout << a << " ";
}
template <class T>
T gcd(T a, T b) {
  T r;
  while (b != 0) {
    r = a % b;
    a = b;
    b = r;
  }
  return a;
}
template <class T>
T lcm(T a, T b) {
  return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
  return x * x;
}
template <class T>
T cube(T x) {
  return x * x * x;
}
template <class T>
struct Triple {
  T x, y, z;
  Triple() {}
  Triple(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
};
template <class T>
Triple<T> euclid(T a, T b) {
  if (b == 0) return Triple<T>(1, 0, a);
  Triple<T> r = euclid(b, a % b);
  return Triple<T>(r.y, r.x - a / b * r.y, r.z);
}
template <class T>
int getbit(T s, int i) {
  return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
  return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
  return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
  return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
  if (rsz <= 0) {
    ptr = 0;
    rsz = fread(bf, 1, bfsz, stdin);
    if (rsz <= 0) return EOF;
  }
  --rsz;
  return bf[ptr++];
}
void ga(char &c) {
  c = EOF;
  while (!isalpha(c)) c = gc();
}
int gs(char s[]) {
  int l = 0;
  char c = gc();
  while (isspace(c)) c = gc();
  while (c != EOF && !isspace(c)) {
    s[l++] = c;
    c = gc();
  }
  s[l] = '\0';
  return l;
}
template <class T>
bool gi(T &v) {
  v = 0;
  char c = gc();
  while (c != EOF && c != '-' && !isdigit(c)) c = gc();
  if (c == EOF) return false;
  bool neg = c == '-';
  if (neg) c = gc();
  while (isdigit(c)) {
    v = v * 10 + c - '0';
    c = gc();
  }
  if (neg) v = -v;
  return true;
}
const double PI = 2 * acos(0);
const string months[] = {"January",   "February", "March",    "April",
                         "May",       "June",     "July",     "August",
                         "September", "October",  "November", "December"};
const int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dr[] = {-1, 0, +1, 0};
const int dc[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const double eps = 1e-9;
struct rbtree {
  struct node {
    int size, red, alive;
    node *l, *r;
    long long key, sum;
    void update() {
      size = alive + l->size + r->size;
      sum = key * alive + l->sum + r->sum;
    }
  } * root, *nil;
  node *create(int key) {
    node *x = new node();
    x->sum = x->key = key;
    x->size = 1;
    x->red = x->alive = 1;
    x->l = x->r = nil;
    return x;
  }
  rbtree() {
    root = nil = new node();
    nil->size = 0;
    nil->red = nil->alive = 0;
    nil->key = nil->sum = 0;
    nil->l = nil->r = nil;
  }
  node *rotate(node *x, node *y) {
    if (y == x->l) {
      x->l = y->r;
      y->r = x;
    } else {
      x->r = y->l;
      y->l = x;
    };
    y->red = x->red;
    x->red = 1;
    x->update();
    y->update();
    return y;
  }
  node *insert(node *x, int &key) {
    if (x == nil) return create(key);
    if (x->l->red && x->r->red) {
      x->l->red = x->r->red = 0;
      x->red ^= 1;
    }
    if (key == x->key)
      x->alive++;
    else
      key < x->key ? x->l = insert(x->l, key) : x->r = insert(x->r, key);
    x->update();
    if (x->r->red) x = rotate(x, x->r);
    if (x->l->red && x->l->l->red) x = rotate(x, x->l);
    return x;
  }
  void erase(node *x, int &key) {
    if (x == nil) return;
    if (key == x->key) {
      if (x->alive > 0) x->alive--;
    } else
      key < x->key ? erase(x->l, key) : erase(x->r, key);
    x->update();
  }
  int size() { return root->size; }
  void insert(int key) { root = insert(root, key); }
  void erase(int key) { erase(root, key); }
  long long sumk(int k) {
    if (k == 0) return 0;
    if (k >= root->size) return abs(root->sum);
    long long ret = 0;
    node *x = root;
    int pos = 0;
    while (x != nil) {
      if (x->l->size >= k)
        x = x->l;
      else {
        pos = x->l->size + x->alive;
        if (pos >= k && x->alive) {
          ret += x->l->sum;
          k -= x->l->size;
          if (k > 0) ret += k * x->key;
          break;
        }
        if (pos >= k)
          x = x->l;
        else {
          k -= pos;
          ret += x->l->sum + x->key * x->alive;
          x = x->r;
        }
      }
    }
    return abs(ret);
  }
};
int n, K;
long long a[200005], sum;
int main() {
  gi(n);
  gi(K);
  gi(sum);
  for (typeof(n) i = (1); i <= (n); ++i) gi(a[i]);
  int res = n;
  rbtree tree;
  for (typeof(n - 1) i = (n - 1); i >= (1); --i) {
    if (a[i] > sum)
      res = min(res, i);
    else {
      long long remain = sum - a[i];
      if (tree.size() > 0 && K > 0) {
        if (tree.sumk(K - 1) > remain) {
          res = min(res, i);
        }
      }
    }
    tree.insert(-a[i]);
  }
  printf("%d\n", res);
  return 0;
}
