#include <bits/stdc++.h>

using namespace std;

template<typename T>
ostream& operator << (ostream &os, const vector<T> &v) {
    os << "[";
    for (int i = 0; i < v.size(); ++i) {
        if (i) {
            os << " ";
        }
        os << v[i];
    }
    os << "]";
    return os;
}

namespace ntt {

const int max_lev = 20;
const int max_n = 1 << max_lev, mod = 998244353;

int mul(int x, int y) {
    return (1LL * x * y) % mod;
}

int power(int x, int y) {
    if (y == 0) {
        return 1;
    }
    if (y % 2 == 0) {
        return power(mul(x, x), y / 2);
    }
    return mul(x, power(x, y - 1));
}

int find_root() {
    for (int root = 2; ; ++root) {
        if (power(root, max_n) == 1) {
            int cur = 1;
            bool ok = true;
            for (int i = 1; i < max_n; ++i) {
                cur = mul(cur, root);
                if (cur == 1) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                return root;
            }
        }
    }
}

int pw[max_n], rpw[max_n], rev[max_n];

void init() {
    int root = find_root();
    int rroot = power(root, mod - 2);
    pw[0] = rpw[0] = 1;
    for (int i = 1; i < max_n; ++i) {
        pw[i] = mul(pw[i - 1], root);
        rpw[i] = mul(rpw[i - 1], rroot);
        rev[i] = (rev[i / 2] / 2) + ((i & 1) << (max_lev - 1));
    }
}

void fft(vector<int> &a, int pw[], int lg) {
    for (int i = 0; i < a.size(); ++i) {
        int r = (rev[i] >> (max_lev - lg)) & (a.size() - 1);
        if (i < r) {
            swap(a[i], a[r]);
        }
    }
    int pl = max_n / 2;
    for (int st = 1; st < a.size(); st *= 2) {
        for (int i = 0; i < a.size(); i += 2 * st) {
            int cur = 0;
            for (int j = i; j < i + st; ++j) {
                int y = mul(pw[cur], a[j + st]);
                a[j + st] = (a[j] + mod - y) % mod;
                a[j] = (a[j] + y) % mod;
                cur += pl;
            }
        }
        pl /= 2;
    }
}

vector<int> product(vector<int> &a, vector<int> &b) {
    if (pw[0] == 0) {
        puts("NTT was not initialized");
        exit(228);
    }
    int sz = a.size() + b.size() - 1;
    int N = 1, lg = 0;
    while (N < sz) {
        N *= 2;
        ++lg;
    }
    while (a.size() < N) {
        a.push_back(0);
    }
    while (b.size() < N) {
        b.push_back(0);
    }
    fft(a, pw, lg);
    fft(b, pw, lg);
    for (int i = 0; i < a.size(); ++i) {
        a[i] = mul(a[i], b[i]);
    }
    fft(a, rpw, lg);
    int rn = power(N, mod - 2);
    vector<int> ans(sz);
    for (int i = 0; i < sz; ++i) {
        ans[i] = mul(a[i], rn);
    }
    return ans;
}

vector<int> square(vector<int> &a) {
    if (pw[0] == 0) {
        puts("NTT was not initialized");
        exit(228);
    }
    int sz = a.size() + a.size() - 1;
    int N = 1, lg = 0;
    while (N < sz) {
        N *= 2;
        ++lg;
    }
    while (a.size() < N) {
        a.push_back(0);
    }
    fft(a, pw, lg);
    for (int i = 0; i < a.size(); ++i) {
        a[i] = mul(a[i], a[i]);
    }
    fft(a, rpw, lg);
    int rn = power(N, mod - 2);
    vector<int> ans(sz);
    for (int i = 0; i < sz; ++i) {
        ans[i] = mul(a[i], rn);
    }
    return ans;
}

}

const int max_n = 200222, inf = 1000111222;
const int mod = 200003;
const int g = 2;

int mul(int x, int y) {
    return (1LL * x * y) % mod;
}

int n, a[max_n];
int pw[max_n], lg[max_n];
long long ans;

const int sq = 555;

vector<int> A(mod), B(mod), C(mod);

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    ntt::init();
    pw[0] = 1;
    for (int i = 1; i + 1 < mod; ++i) {
        pw[i] = mul(pw[i - 1], g);
    }
    memset(lg, -1, sizeof(lg));
    for (int i = 0; i + 1 < mod; ++i) {
        assert(lg[pw[i]] == -1);
        lg[pw[i]] = i;
    }
    if (1) {
        scanf("%d", &n);
        for (int i = 0; i < n; ++i) {
            scanf("%d", &a[i]);
            if (!a[i]) {
                --n;
                --i;
            }
        }
    } else {
        n = 200000;
        for (int i = 0; i < n; ++i) {
            a[i] = 12345;
        }
        cout << 1LL * mul(a[0], a[0]) * n * (n - 1) / 2 << endl;
    }
    for (int i = 0; i < n; ++i) {
        ans -= mul(a[i], a[i]);
        a[i] = lg[a[i]];
        ++A[a[i]];
    }
    for (int i = 0; i < A.size(); ++i) {
        B[i] = A[i] / sq;
        C[i] = A[i] % sq;
        //assert(!B[i] && C[i] == A[i]);
    }
    vector<int> CC = C;
    vector<int> BB = B;
    vector<int> c1 = ntt::square(B);
    vector<int> c2 = ntt::product(BB, CC);
    vector<int> c3 = ntt::square(C);
    //vector<int> c = ntt::square(A);
    for (int i = 0; i < c1.size(); ++i) {
        //assert(!c1[i] && !c2[i] && c[i] == c3[i]);
        long long cnt = 1LL * sq * sq * c1[i];
        cnt += 2LL * sq * c2[i];
        cnt += c3[i];
        if (0 && cnt) {
            cout << i << ": " << cnt << " " << pw[i % (mod - 1)] << endl;
        }
        ans += 1LL * cnt * pw[i % (mod - 1)];
    }
    assert(ans % 2 == 0);
    ans /= 2;
    cout << ans << "\n";
    return 0;
}


Measured memory_bytes: 31532