— Thanks a lot for today.

— I experienced so many great things.

— You gave me memories like dreams... But I have to leave now...

— One last request, can you...

— Help me solve a Codeforces problem?

— ......

— What?

Chtholly has been thinking about a problem for days:

If a number is palindrome and length of its decimal representation without leading zeros is even, we call it a zcy number. A number is palindrome means when written in decimal representation, it contains no leading zeros and reads the same forwards and backwards. For example 12321 and 1221 are palindromes and 123 and 12451 are not. Moreover, 1221 is zcy number and 12321 is not.

Given integers k and p, calculate the sum of the k smallest zcy numbers and output this sum modulo p.

Unfortunately, Willem isn't good at solving this kind of problems, so he asks you for help!

Input

The first line contains two integers k and p (1 ≤ k ≤ 105, 1 ≤ p ≤ 109).

Output

Output single integer — answer to the problem.

Examples

Input

2 100


Output

33


Input

5 30


Output

15

Note

In the first example, the smallest zcy number is 11, and the second smallest zcy number is 22.

In the second example, <image>.
/* LA KE 3 PEG BALLIYE MUNDA KRDA CODE
*/
//import com.sun.deploy.util.StringUtils;
//import sun.reflect.generics.tree.Tree;

//import javax.print.attribute.HashDocAttributeSet;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;

/* Built using CHelper plug-in
* Solution By SANYAM ARORA
*/
//MY CODE STARTS HERE//

public class codeforces{
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Ques solver;
        solver = new Ques();
        //int testNumber=in.nextInt();
        //while(testNumber-->0)
        solver.solve(1, in, out);
        out.close();
    }

    static class Ques {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int n=in.nextInt();
            long p=in.nextLong();
            long sum=0;
            for (int i = 1; i <= n; i++) {
                String s = Integer.toString(i);
                String ss = StringUtils.reverse(s);
                s = s + ss;
                long cur = Long.parseLong(s);
                sum += cur;
                sum %= p;
            }
            out.print(sum);
    /*        for(int i = 0;i<n;i++)
                sun=((sun%p)+(al.get(i)%p))%p;
            out.println(sun);
            out.println(al);*/

        }
    }
    static class StringUtils {
        public static String reverse(String sample) {
            StringBuilder result = new StringBuilder(sample);
            result.reverse();
            return result.toString();
        }

    }
    static long d, x, y;
    static void extendedEuclid(long A, long B) {
        if(B == 0) {
            d = A;
            x = 1;
            y = 0;
        }
        else {
            extendedEuclid(B, A%B);
            long temp = x;
            x = y;
            y = temp - (A/B)*y;
        }
    }
    static long modInverse(long A, long M)
    {
        extendedEuclid(A,M);
        return (x%M+M)%M;
    }
    static long modPow(long x,long y,long M){
        if(y==0) return 1;
        if(y%2==0) return modPow((x*x)%M,y/2,M);
        else return (x*modPow((x*x)%M,(y-1)/2,M))%M;
    }
    static long M = (long) Math.pow(10,9)+7;
    //MY CODE END HERE//

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[8192];
        private int curChar;
        private int pnumChars;
        private FastReader.SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (pnumChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= pnumChars) {
                curChar = 0;
                try {
                    pnumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (pnumChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }
        private String readLine0(){
            StringBuilder buf = new StringBuilder ();
            int c = read ();
            while (c != '\n' && c != -1){
                if (c != '\r'){
                    buf.appendCodePoint (c);
                }
                c = read ();
            }
            return buf.toString ();
        }
        public String nextLine(){
            String s = readLine0 ();
            while (s.trim ().length () == 0)
                s = readLine0 ();
            return s;
        }
        public String nextLine(boolean ignoreEmptyLines){
            if (ignoreEmptyLines){
                return nextLine ();
            }else{
                return readLine0 ();
            }
        }
        public char nextCharacter(){
            int c = read ();
            while (isSpaceChar (c))
                c = read ();
            return (char) c;
        }

        public double nextDouble(){
            int c = read ();
            while (isSpaceChar (c))
                c = read ();
            int sgn = 1;
            if (c == '-'){
                sgn = -1;
                c = read ();
            }
            double res = 0;
            while (!isSpaceChar (c) && c != '.'){
                if (c == 'e' || c == 'E'){
                    return res * Math.pow (10, nextInt ());
                }
                if (c < '0' || c > '9'){
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read ();
            }
            if (c == '.'){
                c = read ();
                double m = 1;
                while (!isSpaceChar (c)){
                    if (c == 'e' || c == 'E'){
                        return res * Math.pow (10, nextInt ());
                    }
                    if (c < '0' || c > '9'){
                        throw new InputMismatchException ();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read ();
                }
            }
            return res * sgn;
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c == ',') {
                    c = read();
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public String next() {
            return nextString();
        }
        public int[] nextIntArray(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public String nextString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
        public BigInteger nextBigInteger(){
            try{
                return new BigInteger (nextString());
            } catch (NumberFormatException e){
                throw new InputMismatchException ();
            }
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}