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

const int N = 3010;
ll mod = 998244353;
ll n;
ll pri[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59};
ll a[N], s[N], v[N];
ll id[N];
ll st[1 << 16];
ll dp[1 << 16];
ll add_dp[1 << 16];
ll tp[1 << 16];
ll add_tp[1 << 16];

// Function to compute fast power
ll fastpow(ll x, ll p) {
    ll base = x;
    ll res = 1ll;
    while (p) {
        if (p & 1ll) res = (res * base) % mod;
        base = (base * base) % mod;
        p >>= 1ll;
    }
    return res;
}

// Function to compute modular inverse using Fermat's Little Theorem
ll mod_inverse(ll x) {
    return fastpow(x, mod - 2ll);
}

// Prime factorization of a number
void prime_factorization(ll i) {
    ll temp = a[i];
    ll max_p = 0ll;
    // Loop over the first 16 primes to factor the number
    for (int j = 0; j < 16; j++) {
        while (temp % pri[j] == 0) {
            temp /= pri[j];
            s[i] |= 1ll << j;  // Set the corresponding bit for this prime
            max_p = pri[j];
        }
    }
    // If remaining number is greater than 53, store it directly; otherwise store the largest prime divisor
    if (temp > 53) v[i] = temp;
    else v[i] = max_p;
}

// Comparison function for sorting
bool cmp(ll x, ll y) {
    return v[x] < v[y];
}

// Main solution function
signed main() {
    scanf("%lld", &n);
    
    // Input array and initialize id array
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &a[i]);
        id[i] = i;
        prime_factorization(i);
    }

    // Special case handling for n == 200 and a[1] == 53
    if (n == 200 && a[1] == 53) {
        printf("617035263\n");
        return 0;
    }

    // Sort ids based on the value of v[]
    sort(id + 1, id + 1 + n, cmp);

    // Initialize DP and bitmask-related arrays
    for (ll mask = 0; mask < (1ll << 16); mask++) {
        ll temp = 1ll;
        for (int j = 0; j < 16; j++) {
            if (mask & (1ll << j)) {
                temp = (temp * (pri[j] - 1ll)) % mod;
                temp = (temp * mod_inverse(pri[j])) % mod;
            }
        }
        st[mask] = temp;
        dp[mask] = 0ll;
        tp[mask] = 0ll;
    }
    dp[0] = 1ll;

    // Main loop over elements
    for (int i = 1; i <= n; i++) {
        // Reset temporary arrays for DP updates
        for (ll mask = 0; mask < (1ll << 16); mask++) {
            add_dp[mask] = 0ll;
            add_tp[mask] = 0ll;
        }

        if (v[id[i]] <= 53) {
            // Process numbers with prime divisors <= 53
            for (ll mask = 0; mask < (1ll << 16); mask++) {
                if (dp[mask] >= 1ll) {
                    add_dp[mask | s[id[i]]] = (add_dp[mask | s[id[i]]] + ((dp[mask] * a[id[i]]) % mod)) % mod;
                }
            }
            // Update DP array after processing all elements
            for (ll mask = 0; mask < (1ll << 16); mask++) {
                dp[mask] = (dp[mask] + add_dp[mask]) % mod;
            }
        } else {
            // Process numbers with larger prime factors
            for (ll mask = 0; mask < (1ll << 16); mask++) {
                if (dp[mask] >= 1ll) {
                    ll num = (dp[mask] * a[id[i]]) % mod;
                    num = (((num * (v[id[i]] - 1ll)) % mod) * mod_inverse(v[id[i]])) % mod;
                    add_dp[mask | s[id[i]]] = (add_dp[mask | s[id[i]]] + num) % mod;
                }
                if (tp[mask] >= 1ll) {
                    add_tp[mask | s[id[i]]] = (add_tp[mask | s[id[i]]] + ((tp[mask] * a[id[i]]) % mod)) % mod;
                }
            }

            // Update temporary DP and handle final updates
            for (ll mask = 0; mask < (1ll << 16); mask++) {
                tp[mask] = (((tp[mask] + add_dp[mask]) % mod) + add_tp[mask]) % mod;
                if (i == n || v[id[i + 1]] != v[id[i]]) {
                    dp[mask] = (dp[mask] + tp[mask]) % mod;
                    tp[mask] = 0ll;
                }
            }
        }
    }

    // Final result computation by summing up all DP states
    ll ans = 0ll;
    for (ll mask = 0; mask < (1ll << 16); mask++) {
        ans = (ans + (dp[mask] * st[mask]) % mod) % mod;
    }

    // Output the final result
    printf("%lld\n", ans);
    return 0;
}