#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &a, const T &b) {
  if (b < a) a = b;
}
template <class T>
inline void amax(T &a, const T &b) {
  if (a < b) a = b;
}
template <int MOD>
struct ModInt {
  unsigned x;
  void undef() { x = -1; }
  bool isnan() const { return x == -1; }
  inline int getInt() const { return (int)x; }
  template <class T>
  T get() const {
    return (T)x;
  }
  inline int mod() const { return MOD; }
  ModInt(int y = 0) {
    if (y < 0 || MOD <= y) y %= MOD;
    if (y < 0) y += MOD;
    x = y;
  }
  ModInt(long long y) {
    if (y < 0 || MOD <= y) y %= MOD;
    if (y < 0) y += MOD;
    x = y;
  }
  ModInt(unsigned long long y) {
    if (MOD <= y)
      x = y % MOD;
    else
      x = y;
  }
  ModInt &operator+=(const ModInt &y) {
    if ((x += y.x) >= MOD) x -= MOD;
    return *this;
  }
  ModInt &operator-=(const ModInt &y) {
    if ((x += MOD - y.x) >= MOD) x -= MOD;
    return *this;
  }
  ModInt &operator*=(const ModInt &y) {
    x = (unsigned long long)x * y.x % MOD;
    return *this;
  }
  ModInt &operator/=(const ModInt &y) {
    x = (unsigned long long)x * y.inv().x % MOD;
    return *this;
  }
  ModInt operator-() const { return (x ? MOD - x : 0); }
  ModInt inv() const {
    int a = MOD, b = x, u = 0, v = 1;
    while (b) {
      int t = a / b;
      a -= t * b;
      swap(a, b);
      u -= t * v;
      swap(u, v);
    }
    if (u < 0) u += MOD;
    return ModInt(u);
  }
  ModInt pow(long long y) const {
    ModInt b = *this, r = 1;
    if (y < 0) {
      b = b.inv();
      y = -y;
    }
    for (; y; y >>= 1) {
      if (y & 1) r *= b;
      b *= b;
    }
    return r;
  }
};
const long long MOD = 1000000007;
ModInt<MOD> operator+(ModInt<MOD> x, const ModInt<MOD> &y) {
  if ((x.x += y.x) >= (unsigned)x.mod()) x.x -= x.mod();
  return x;
}
ModInt<MOD> operator-(ModInt<MOD> x, const ModInt<MOD> &y) {
  if ((x.x += x.mod() - y.x) >= (unsigned)x.mod()) x.x -= x.mod();
  return x;
}
ModInt<MOD> operator*(ModInt<MOD> x, const ModInt<MOD> &y) {
  x.x = (unsigned long long)x.x * y.x % x.mod();
  return x;
}
ModInt<MOD> operator/(ModInt<MOD> x, const ModInt<MOD> &y) {
  x.x = (unsigned long long)x.x * y.inv().x % x.mod();
  return x;
}
bool operator<(const ModInt<MOD> &x, const ModInt<MOD> &y) { return x.x < y.x; }
bool operator==(const ModInt<MOD> &x, const ModInt<MOD> &y) {
  return x.x == y.x;
}
bool operator!=(const ModInt<MOD> &x, const ModInt<MOD> &y) {
  return x.x != y.x;
}
template <class T>
struct Fenwick : vector<T> {
  int N;
  Fenwick(int N_ = 0) : vector<T>(N_), N(N_) {}
  void add(int i, T x) {
    for (; i < N; i |= i + 1) vector<T>::operator[](i) += x;
  }
  T sum(int l, int r) {
    if (l == 0) {
      T s = 0;
      for (; r; r &= r - 1) s += vector<T>::operator[](r - 1);
      return s;
    } else {
      return sum(0, r) - sum(0, l);
    }
  }
};
int N, K;
long long L;
int A[1000011], As[1000011];
int main() {
  scanf("%d%lld%d", &N, &L, &K);
  for (int i = 0, i_len = (N); i < i_len; ++i) scanf("%d", A + i);
  for (int i = 0, i_len = (N); i < i_len; ++i) As[i] = A[i];
  sort(As, As + N);
  ModInt<MOD> ans = 0;
  if ((long long)N * K >= L) {
    Fenwick<ModInt<MOD> > F(N);
    for (int i = 0, i_len = (K); i < i_len; ++i) {
      Fenwick<ModInt<MOD> > Fn(N);
      for (int j = 0, j_len = (min<long long>(N, L)); j < j_len; ++j) {
        int p = upper_bound(As, As + N, A[j]) - As;
        Fn.add(p - 1, F.sum(0, p) + 1);
      }
      swap(Fn, F);
      L -= N;
      ans += F.sum(0, N);
      if (L <= 0) break;
    }
  } else {
    if (L % N) {
      Fenwick<ModInt<MOD> > F(N);
      F.add(0, 1);
      for (int i = 0, i_len = (K); i < i_len; ++i) {
        Fenwick<ModInt<MOD> > Fn(N);
        for (int j = 0, j_len = (L % N); j < j_len; ++j) {
          int p = upper_bound(As, As + N, A[j]) - As;
          Fn.add(p - 1, F.sum(0, p));
        }
        ans += Fn.sum(0, N);
        for (int j = L % N; j < N; j++) {
          int p = upper_bound(As, As + N, A[j]) - As;
          Fn.add(p - 1, F.sum(0, p));
        }
        swap(Fn, F);
      }
    }
    {
      Fenwick<ModInt<MOD> > F(N);
      F.add(0, 1);
      for (int i = 0, i_len = (K); i < i_len; ++i) {
        Fenwick<ModInt<MOD> > Fn(N);
        for (int j = 0, j_len = (N); j < j_len; ++j) {
          int p = upper_bound(As, As + N, A[j]) - As;
          Fn.add(p - 1, F.sum(0, p));
        }
        swap(Fn, F);
        ans += F.sum(0, N) * (L / N - i);
      }
    }
  }
  printf("%d\n", ans.getInt());
  return 0;
}
