// Go in my style.
// Not afraid to dark.

#include <bits/stdc++.h>
using namespace std;

clock_t start_time, end_time;
#define GET_START start_time = clock ();
#define GET_END end_time = clock (); fprintf (stderr, "TIME COSSEMED : %0.3lf\n", 1.0 * (end_time - start_time) / CLOCKS_PER_SEC);
#define inline __inline__ __attribute__ ((always_inline))

#define int long long
#define i128 __int128

namespace io {
    int read_pos, read_dt; char read_char;
    inline int read (int &p = read_pos){
        p = 0, read_dt = 1; read_char = getchar ();
        while (! isdigit (read_char)){
            if (read_char == '-')
                read_dt = - 1;
            read_char = getchar ();
        }
        while (isdigit (read_char)){
            p = (p << 1) + (p << 3) + read_char - 48;
            read_char = getchar ();
        }
        return p = p * read_dt;
    }
    int write_sta[65], write_top;
    inline void write (int x){
        if (x < 0)
            putchar ('-'), x = - x;
        write_top = 0;
        do
            write_sta[write_top ++] = x % 10, x /= 10;
        while (x);
        while (write_top)
            putchar (write_sta[-- write_top] + 48);
    }
}

int n, r;

namespace NUMBER {

    mt19937_64 mtrand (time (0));

    inline int power (int a, int p, int mod){
        int res = 1;
        while (p > 0){
            if (p & 1)
                res = (i128) res * a % mod;
            a = (i128) a * a % mod;
            p >>= 1;
        }
        return res;
    }
    int gcd (int i, int j){
        if (j == 0)
            return i;
        return gcd (j, i % j);
    }
    #define log2_(x) (63 ^ __builtin_clzll (x))

    int ae[7] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
    inline bool MR (int p){
        if (p < 2)
            return false;
        if (p < 4)
            return true;
        static int d, r; d = p - 1, r = 0;
        while (! (d & 1))
            d >>= 1, ++ r;
        for (int i = 0, a, x, T;i < 7;++ i){
            a = ae[i] % p;
            if (a == 1 || a == p - 1 || a == 0)
                continue;
            x = power (a, d, p);
            if (x == 1)
                continue;
            for (T = r;T --;){
                if (x == p - 1)
                    break;
                x = (i128) x * x % p;
            }
            if (T < 0)
                return false;
        }
        return true;
    }
    inline int PR (int p){
        static int s, t, c, i, ed, prd, d;
        s = t = 0, c = mtrand () % (p - 1) + 1;
        for (ed = 1;;ed <<= 1){
            prd = 1, s = t;
            for (i = 1;i <= ed;++ i){
                t = ((i128) t * t + c) % p;
                prd = (i128) prd * abs (t - s) % p;
                if (i % 127 == 0){
                    d = gcd (prd, p);
                    if (d > 1)
                        return d;
                }
            }
            d = gcd (prd, p);
            if (d > 1)
                return d;
        }
        return - 1;
    }
    void FAC (int p, vector < int > &fac, int t = 1){
        if (p < 2)
            return ;
        if (MR (p)){
            while (t --)
                fac.push_back (p);
            return ;
        }
        int x;
        do
            x = PR (p);
        while (x >= p);
        int r = 0;
        while (p % x == 0)
            p /= x, ++ r;
        FAC (p, fac, t), FAC (x, fac, t * r);
    }
} using namespace NUMBER;

const int mod = 998244353;

#define sgn(x) ((x) & 1 ? - 1 : 1)

inline int Solve (int p){
    static int C, res, pp, C0; pp = p % mod;
    C0 = ((pp - 1) * sgn (p - 1 >> 1) % mod + pp) % mod;
    C0 = (C0 + mod) % mod;
    if (p == 2) C = C0 = 2;
    else if (r % p == 0) C = C0;
    else C = (pp - sgn (p - 1 >> 1)) % mod, C = (C + mod) % mod;
    if (r % p == 0){
        res = (C - 1) * (pp - 1) % mod * (pp - 1) % mod;
        res = (res + 3ll * pp % mod * pp % mod * pp % mod - 3ll * pp % mod + 1) % mod;
    } else {
        res = C * pp % mod;
        res = (res + (pp * pp % mod - 1) * pp % mod - (pp * pp % mod - C0) % mod) % mod;
    }
    res = (res + mod) % mod;
    return res;
}

signed main (){
    GET_START

    io::read (n), io::read (r);
    int ans = 1;
    vector < int > fac; FAC (n, fac);
    for (int p : fac)
        ans = ans * Solve (p) % mod;
    io::write (ans), putchar ('\n');

    GET_END
    return 0;
}