#include <array>
#include <cstdint>
#include <ios>
#include <iostream>
#include <utility>
#include <vector>

template <typename T, typename U>
T exponentiate(T base, U pow, const T& id = T(1)) {

    T res = id;

    while (pow > 0) {
        if (pow & 1) {
            res *= base;
        }
        pow >>= 1;
        base *= base;
    }

    return res;

}

template <typename T>
std::array<T, 3> extended_gcd(T m, T n) {

    T a = 1;
    T a_in = 0;
    T b = 0;
    T b_in = 1;

    while (n) {
        const T q = m / n;
        a_in = std::exchange(a, a_in) - a_in * q;
        b_in = std::exchange(b, b_in) - b_in * q;
        n = std::exchange(m, n) - n * q;
    }

    return std::array<T, 3>({m, a, b});

}

template <std::int32_t>
class dynamic_modular_integer {

private:

    static inline std::int32_t modulus;

public:

    static std::int32_t get_modulus() {

        return modulus;

    }

    static void set_modulus(std::int32_t mod) {

        modulus = mod;

    }

    std::int32_t val;

    explicit dynamic_modular_integer() : dynamic_modular_integer(0) {}

    explicit dynamic_modular_integer(std::int64_t val) : val(val % get_modulus()) {

        if (this->val < 0) {
            this->val += get_modulus();
        }

    }

    dynamic_modular_integer operator-() const {

        return dynamic_modular_integer(-val);

    }

    void operator++() {

        *this += dynamic_modular_integer(1);

    }

    void operator--() {

        *this -= dynamic_modular_integer(1);

    }

    void operator+=(dynamic_modular_integer other) {

        if (other.val >= get_modulus() - val) {
            val -= get_modulus();
        }

        val += other.val;

    }

    void operator-=(dynamic_modular_integer other) {

        val -= other.val;

        if (val < 0) {
            val += get_modulus();
        }

    }

    void operator*=(dynamic_modular_integer other) {

        val = (std::int64_t(val) * other.val) % get_modulus();

    }

    void operator/=(dynamic_modular_integer other) {

        *this *= dynamic_modular_integer(extended_gcd(other.val, get_modulus())[1]);

    }

    friend dynamic_modular_integer operator+(
        dynamic_modular_integer lhs, dynamic_modular_integer rhs
    ) {

        lhs += rhs;

        return lhs;

    }

    friend dynamic_modular_integer operator-(
        dynamic_modular_integer lhs, dynamic_modular_integer rhs
    ) {

        lhs -= rhs;

        return lhs;

    }

    friend dynamic_modular_integer operator*(
        dynamic_modular_integer lhs, dynamic_modular_integer rhs
    ) {

        lhs *= rhs;

        return lhs;

    }

    friend dynamic_modular_integer operator/(
        dynamic_modular_integer lhs, dynamic_modular_integer rhs
    ) {

        lhs /= rhs;

        return lhs;

    }

};

void solve() {

    using num_t = dynamic_modular_integer<0>;

    std::int32_t m;
    std::int32_t n;
    std::int32_t p;
    std::int32_t x;

    std::cin >> n >> x >> p >> m;

    num_t::set_modulus(p);

    std::vector<num_t> dp;
    num_t sum;

    for (std::int32_t i = n - m; i <= n; ++i) {
        const std::int32_t sz = i - (n - m) + 1;
        std::vector<num_t> n_dp(sz);
        n_dp[0] = exponentiate(num_t(x + 1), i);
        for (std::int32_t j = 1; j < sz; ++j) {
            n_dp[j] = (n_dp[j - 1] - dp[j - 1]) * num_t(i);
        }
        dp = std::move(n_dp);
    }

    for (std::int32_t i = 0; i <= m; ++i) {
        std::int32_t a;
        std::cin >> a;
        sum += num_t(a) * dp[i];
    }

    std::cout << sum.val << '\n';

}

int main() {

    std::cin.tie(nullptr);

    std::ios_base::sync_with_stdio(false);

    solve();

    return 0;

}