#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;

// template {{{  0 
// using {{{ 1
using ll = long long int;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
// }}} 1
// definition {{{ 1
// scaning {{{ 2
#define Scd(x) scanf("%d", &x)
#define Scd2(x,y) scanf("%d%d", &x, &y)
#define Scd3(x,y,z) scanf("%d%d%d", &x, &y, &z)
#define Scll(x) scanf("%lld", &x)
#define Scll2(x,y) scanf("%lld%lld", &x, &y)
#define Scll3(x,y,z) scanf("%lld%lld%lld", &x, &y, &z)
#define Scc(c) scanf("%c", &c);
#define Scs(s) scanf("%s", s);
#define Scstr(s) scanf("%s", &s);
// }}} 2
// constants {{{ 2
#define EPS (1e-7)
#define INF (2e9)
#define PI (acos(-1))
// }}} 2
// systems {{{ 2
#define Repe(x,y,z) for(ll x = z; x < y; x++)
#define Rep(x,y) Repe(x,y,0)
#define RRepe(x,y,z) for(ll x = y-z-1; x >= 0; x--)
#define RRep(x,y) RRepe(x,y,0)
// }}} 2
// output {{{ 2
#define YesNo(a) (a)?printf("Yes\n"):printf("No\n")
#define YESNO(a) (a)?printf("YES\n"):printf("NO\n")
// }}} 2
// }}} 1
// input {{{ 1
// }}} 1
// }}} 0

ll mod = 19191919191919;

// PowMod( base, index, modulo) return base ** index % modulo {{{
// PowMod = base ** index % mod ( natural numbers )
inline constexpr long long int PowMod( long long int base, long long int index, long long int modulo = mod ){
    if( index == 0 ) return 1;
    // O( log(index) )
    if( index % 2 ){
        return base * PowMod(base, index - 1, modulo) % modulo;
    }else{
        long long int Phalf = index / 2;
        long long int half = PowMod(base, Phalf, modulo);
        return half * half % modulo;
    }
}
// }}}
// modint {{{

struct modint{
    long long int a;
    inline modint( long long int x = 0 ) noexcept : a(x % mod) {}
    inline long long int &value() noexcept { return a; }
    inline const long long int &value() const noexcept { return a; }
    inline modint operator+(const modint rhs) const noexcept{ return modint(*this) += rhs; }
    inline modint operator+(const int rhs) const noexcept{ return modint(*this) += rhs; }
    inline modint operator+(const long long int rhs) const noexcept{ return modint(*this) += rhs; }
    inline modint operator-(const modint rhs) const noexcept{ return modint(*this) -= rhs; }
    inline modint operator-(const int rhs) const noexcept{ return modint(*this) -= rhs; }
    inline modint operator-(const long long int rhs) const noexcept{ return modint(*this) -= rhs; }
    inline modint operator*(const modint rhs) const noexcept{ return modint(*this) *= rhs; }
    inline modint operator*(const int rhs) const noexcept{ return modint(*this) *= rhs; }
    inline modint operator*(const long long int rhs) const noexcept{ return modint(*this) *= rhs; }
    inline modint operator/(const modint rhs) const noexcept{ return modint(*this) /= rhs; }
    inline modint operator/(const int rhs) const noexcept{ return modint(*this) /= rhs; }
    inline modint operator/(const long long int rhs) const noexcept{ return modint(*this) /= rhs; }
    inline modint operator+=(const modint rhs) noexcept{ a += rhs.a; if( a >= mod ) a -= mod; return *this; }
    inline modint operator-=(const modint rhs) noexcept{ a -= rhs.a; if( a < 0 ) a += mod; return *this; }
    inline modint operator*=(const modint rhs) noexcept{ a = a * rhs.a % mod ;  return *this; }
    inline modint operator/=(const modint rhs) noexcept{ a = a * PowMod(rhs.a,mod-2) % mod; return *this; }
};

// }}}

// Matrix Definition{{{

template< class T >
struct Matrix{
    vector< vector<T> > A;

    Matrix(){};
    Matrix( int n, int m ) {
        A.assign(n,vector<T>(m,0));
    };
    Matrix( int n ) {
        A.assign(n,vector<T>(n,0));
    };

    int height() const {
        return (A.size());
    }

    int width() const {
        return (A[0].size());
    }

    inline vector<T> &operator[]( int k ) {
        return (A.at(k));
    }

    inline const vector<T> &operator[]( int k ) const {
        return (A.at(k));
    }

    // 単位行列
    static Matrix E( int n ){
        Matrix mat(n);
        for( int i = 0; i < n; i++ ) mat[i][i] = 1;
        return mat;
    }

    Matrix &operator+=( const Matrix &B ){
        int n = height(), m = width();
        assert( n == B.height() && m == B.width() );
        for( int i = 0; i < n; i++ )
            for( int j = 0; j < m; j++ )
                (*this)[i][j] += B[i][j];
        return (*this);
    }

    Matrix &operator-=( const Matrix &B ){
        int n = height(), m = width();
        assert( n == B.height() && m == B.width() );
        for( int i = 0; i < n; i++ )
            for( int j = 0; j < m; j++ )
                (*this)[i][j] -= B[i][j];
        return (*this);
    }

    Matrix &operator*=( const Matrix &B ){
        int n = height(), m = B.width(), p = width();
        assert( p == B.height() );
        vector< vector<T> > C( n, vector<T>(m, 0) );
        for( int i = 0; i < n; i++ )
            for( int j = 0; j < m; j++ )
                for( int k = 0; k < p; k++ )
                    C[i][j] += (*this)[i][k] * B[k][j];
        A.swap(C);
        return (*this);
    }

    Matrix power( ll k ){
        Matrix B = Matrix::E(height());
        while( k > 0 ){
            if( k&1 ) B *= *this;
            *this *= *this;
            k >>= 1;
        }
        A.swap(B.A);
        return *this;
    }

    Matrix operator+(const Matrix &B ) const {
        return (Matrix(*this) += B );
    }
    Matrix operator-(const Matrix &B ) const {
        return (Matrix(*this) -= B );
    }
    Matrix operator*(const Matrix &B ) const {
        return (Matrix(*this) *= B );
    }

    void Print(){
        int n = height(), m = width();
        for( int i = 0; i < n; i++ ){
            printf ("[");
            for( int j = 0; j < m; j++ ){
                printf ("%lld%s", (*this)[i][j], j == m-1 ? "]\n" : "," );
            }
        }
    }

};

// }}}

int main() {

    ll L,A,B;
    ll M;
    Scll3(L,A,B);
    Scll(M);
    mod = M;

    Matrix<modint> ans(1,3);

    ans[0][0] = 0;
    ans[0][1] = A;
    ans[0][2] = 1;

    ll tmp = A;

    ll dig = 1;
    ll maxll = A + B * ( L-1 );
    while(1){
        // printf ("%lld<%lld\n", tmp, dig );
        if( tmp < dig ){
            ll index;
            if( dig <= maxll ){
                index = ( dig - tmp + B - 1 ) / B;
            }else{
                index = ( maxll - tmp + B  ) / B;
            }

            Matrix<modint> C(3,3);

            C[0][0] = dig%mod;
            C[1][0] = 1;
            C[1][1] = 1;
            C[2][1] = B;
            C[2][2] = 1;

            C.power(index);

            ans *= C;

            // ans.Print();

            // printf ("%lld\n", ans[0][0] );

            tmp += index * B;

            if( tmp > maxll ){
                break;
            }
        }
        dig *= 10;
    }

    printf ("%lld\n", ans[0][0] );


    return 0;
}



Measured memory_bytes: 256