#include <bits/stdc++.h>
namespace loquat {
template <typename T>
static std::pair<T, T> extended_gcd(T a, T b) {
  if (b == 0) {
    return std::pair<T, T>(1, 0);
  }
  const auto p = extended_gcd(b, a % b);
  return std::pair<T, T>(p.second, p.first - a / b * p.second);
}
}  // namespace loquat
namespace loquat {
template <int MOD>
class modulus_integer {
 public:
 private:
  int m_value;
  static modulus_integer<MOD> unsafe_construct(int x) noexcept {
    modulus_integer<MOD> y;
    y.m_value = x;
    return y;
  }

 public:
  modulus_integer() noexcept : m_value(0) {}
  modulus_integer(int x) noexcept : m_value(x % MOD) {
    if (m_value < 0) {
      m_value += MOD;
    }
  }
  int operator*() const noexcept { return m_value; }
  modulus_integer<MOD>& operator=(const modulus_integer<MOD>& x) noexcept {
    m_value = x.m_value;
    return *this;
  }
  modulus_integer<MOD> operator+(const modulus_integer<MOD>& x) const noexcept {
    const int y = m_value + x.m_value;
    return unsafe_construct(y >= MOD ? y - MOD : y);
  }
  modulus_integer<MOD> operator*(const modulus_integer<MOD>& x) const noexcept {
    return unsafe_construct(static_cast<long long>(m_value) * x.m_value % MOD);
  }
  modulus_integer<MOD> operator/(const modulus_integer<MOD>& x) const {
    return (*this) * modulus_integer<MOD>(extended_gcd(x.m_value, MOD).first);
  }
  modulus_integer<MOD>& operator+=(const modulus_integer<MOD>& x) noexcept {
    return (*this = *this + x);
  }
  modulus_integer<MOD>& operator*=(const modulus_integer<MOD>& x) noexcept {
    return (*this = *this * x);
  }
};
template <int MOD>
inline std::ostream& operator<<(std::ostream& os,
                                const modulus_integer<MOD>& x) {
  os << *x;
  return os;
}
}  // namespace loquat
using namespace std;
static constexpr int MOD = 1000000009;
using mint = loquat::modulus_integer<MOD>;
inline mint power(mint x, int y) {
  mint z = 1;
  while (y > 0) {
    if (y & 1) {
      z *= x;
    }
    x *= x;
    y >>= 1;
  }
  return z;
}
int main() {
  ios_base::sync_with_stdio(false);
  int n, a, b, k;
  string s;
  cin >> n >> a >> b >> k >> s;
  const mint inv_a = mint(1) / mint(a);
  mint sum = 0, ak = 1, bk = 1;
  for (int i = 0; i < k; ++i) {
    sum += mint(s[i] == '+' ? 1 : -1) * ak * bk;
    ak *= inv_a;
    bk *= mint(b);
  }
  sum *= power(a, n);
  mint x = sum, z = 1, t = ak * bk, answer = 0;
  int y = (n + 1) / k;
  while (y > 0) {
    if (y & 1) {
      answer += x * z;
      z *= t;
    }
    x += x * t;
    t *= t;
    y >>= 1;
  }
  cout << answer << endl;
  return 0;
}
