#include <bits/stdc++.h>
template <typename T>
class IntegerIterator
    : public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T *, T> {
 public:
  explicit IntegerIterator(T value) : value(value) {}
  IntegerIterator &operator++() {
    ++value;
    return *this;
  }
  IntegerIterator operator++(int) {
    IntegerIterator copy = *this;
    ++value;
    return copy;
  }
  IntegerIterator &operator--() {
    --value;
    return *this;
  }
  IntegerIterator operator--(int) {
    IntegerIterator copy = *this;
    --value;
    return copy;
  }
  T operator*() const { return value; }
  bool operator==(IntegerIterator rhs) { return value == rhs.value; }
  bool operator!=(IntegerIterator rhs) { return !(*this == rhs); }

 private:
  T value;
};
template <typename T>
class IntegerRange {
 public:
  IntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
  IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
  IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }

 private:
  T begin_;
  T end_;
};
template <typename T>
class ReversedIntegerRange {
 public:
  ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
  std::reverse_iterator<IntegerIterator<T>> begin() const {
    return std::reverse_iterator<IntegerIterator<T>>(
        IntegerIterator<T>(begin_));
  }
  std::reverse_iterator<IntegerIterator<T>> end() const {
    return std::reverse_iterator<IntegerIterator<T>>(IntegerIterator<T>(end_));
  }

 private:
  T begin_;
  T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
  return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
  return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
  return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
  return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
  return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
  return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
  return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
  return ReversedIntegerRange<T>(from + 1, to);
}
using namespace std;
class TaskD {
 public:
  void solve(istream &in, ostream &out) {
    int n, k, a;
    in >> n >> k >> a;
    int m;
    in >> m;
    set<int> x;
    x.insert(0);
    x.insert(n + 1);
    auto ships = [](int l, int r, int a) {
      int ansl = (r - l - 1) / (a + 1);
      int ansr = 1 + (r - l - 1) / a;
      while (ansr - ansl > 1) {
        int mid = (ansl + ansr) / 2;
        if (mid * a + mid - 1 <= r - l - 1)
          ansl = mid;
        else
          ansr = mid;
      }
      return ansl;
    };
    int max_ships = ships(0, n + 1, a);
    for (auto i : range(m)) {
      int xi;
      in >> xi;
      x.insert(xi);
      auto left_it = x.lower_bound(xi);
      left_it--;
      auto right_it = x.upper_bound(xi);
      int l = *left_it;
      int r = *right_it;
      max_ships += ships(l, xi, a) + ships(xi, r, a) - ships(l, r, a);
      if (max_ships < k) {
        out << i + 1;
        return;
      }
    }
    out << -1;
  }
};
int main() {
  std::ios_base::sync_with_stdio(false);
  TaskD solver;
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  in.tie(0);
  out << std::fixed;
  out.precision(20);
  solver.solve(in, out);
  return 0;
}
