#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <complex>

template <int MOD>
struct ModInt {
    using lint = long long;
    int val;

    // constructor
    ModInt(lint v = 0) : val(v % MOD) {
        if (val < 0) val += MOD;
    };

    // unary operator
    ModInt operator+() const { return ModInt(val); }
    ModInt operator-() const { return ModInt(MOD - val); }
    ModInt inv() const { return this->pow(MOD - 2); }

    // arithmetic
    ModInt operator+(const ModInt& x) const { return ModInt(*this) += x; }
    ModInt operator-(const ModInt& x) const { return ModInt(*this) -= x; }
    ModInt operator*(const ModInt& x) const { return ModInt(*this) *= x; }
    ModInt operator/(const ModInt& x) const { return ModInt(*this) /= x; }
    ModInt pow(lint n) const {
        auto x = ModInt(1);
        auto b = *this;
        while (n > 0) {
            if (n & 1) x *= b;
            n >>= 1;
            b *= b;
        }
        return x;
    }

    // compound assignment
    ModInt& operator+=(const ModInt& x) {
        if ((val += x.val) >= MOD) val -= MOD;
        return *this;
    }
    ModInt& operator-=(const ModInt& x) {
        if ((val -= x.val) < 0) val += MOD;
        return *this;
    }
    ModInt& operator*=(const ModInt& x) {
        val = lint(val) * x.val % MOD;
        return *this;
    }
    ModInt& operator/=(const ModInt& x) { return *this *= x.inv(); }

    // compare
    bool operator==(const ModInt& b) const { return val == b.val; }
    bool operator!=(const ModInt& b) const { return val != b.val; }
    bool operator<(const ModInt& b) const { return val < b.val; }
    bool operator<=(const ModInt& b) const { return val <= b.val; }
    bool operator>(const ModInt& b) const { return val > b.val; }
    bool operator>=(const ModInt& b) const { return val >= b.val; }

    // I/O
    friend std::istream& operator>>(std::istream& is, ModInt& x) noexcept {
        lint v;
        is >> v;
        x = v;
        return is;
    }
    friend std::ostream& operator<<(std::ostream& os, const ModInt& x) noexcept { return os << x.val; }
};

template <int K>
struct FastFourierTransform {
    using ldouble = long double;
    using ldoubles = std::vector<ldouble>;

    using cplx = std::complex<ldouble>;
    using cplxs = std::vector<cplx>;

    static constexpr ldouble PI = 3.14159265358979323846L;

    cplxs zetas;

    explicit FastFourierTransform() : zetas(K) {
        for (int i = 0; i < K; ++i) {
            zetas[i] = std::polar(1.L, PI * 2 / (1 << i));
        }
    }

    void bitrev(cplxs& f) const {
        int n = f.size();

        for (int i = 0; i < n; ++i) {
            int ti = i, ni = 0;
            for (int k = 0; (1 << k) < n; ++k) {
                int b = (ti & 1);
                ti >>= 1;
                ni <<= 1;
                ni += b;
            }

            if (i < ni) {
                std::swap(f[i], f[ni]);
            }
        }
    }

    void udft(cplxs& f, bool isinv) const {
        if (f.size() <= 1) return;

        int l = 1;
        int k = 1 << l;
        int n = f.size();

        while (k <= n) {
            auto zeta = zetas[l];
            if (isinv) zeta = std::conj(zeta);

            for (int r = 0; r < n / k; ++r) {
                cplx zetapow = 1;

                for (int j = 0; j < k / 2; ++j) {
                    int b = r * k + j;
                    auto t = zetapow * f[b + k / 2];

                    f[b + k / 2] = f[b] - t;
                    f[b] = f[b] + t;

                    zetapow *= zeta;
                }
            }

            ++l;
            k <<= 1;
        }
    }

    void dft(cplxs& f, bool isinv) const {
        bitrev(f);
        udft(f, isinv);
    }

    ldoubles fft(const ldoubles& ff, const ldoubles& gf) const {
        auto f = ld2cp(ff),
             g = ld2cp(gf);

        int fdeg = f.size(),
            gdeg = g.size();

        int k = 0;
        while ((1 << k) < fdeg + gdeg) ++k;

        int n = (1 << k);
        f.resize(n, 0);
        g.resize(n, 0);

        dft(f, false);
        dft(g, false);

        cplxs h(n);
        for (int i = 0; i < n; ++i) h[i] = f[i] * g[i];

        dft(h, true);
        h.resize(fdeg + gdeg - 1);
        for (auto& x : h) x /= n;

        return cp2ld(h);
    }

    // long double <-> complex converter
    cplxs ld2cp(const ldoubles& f) const {
        cplxs ret;
        std::transform(f.begin(), f.end(), std::back_inserter(ret),
                       [](auto x) { return cplx(x); });
        return ret;
    }

    ldoubles cp2ld(const cplxs& f) const {
        ldoubles ret;
        std::transform(f.begin(), f.end(), std::back_inserter(ret),
                       [](auto x) { return x.real(); });
        return ret;
    }
};

constexpr int MOD = 200003;
using mint = ModInt<MOD>;
const FastFourierTransform<20> FFT;

using lint = long long;
using ldouble = long double;

void solve() {
    std::vector<int> log(MOD);
    mint root = 2;
    for (int i = 0; i < MOD - 1; ++i) {
        log[root.pow(i).val] = i;
    }

    std::vector<ldouble> cnt(MOD - 1, 0);

    int n;
    std::cin >> n;
    while (n--) {
        int a;
        std::cin >> a;
        if (a != 0) ++cnt[log[a]];
    }

    auto res = FFT.fft(cnt, cnt);

    lint ans = 0;
    for (int i = 0; i < (int)res.size(); ++i) {
        lint num = llround(res[i]);
        ans += root.pow(i).val * num;
    }

    for (int i = 0; i < (int)cnt.size(); ++i) {
        lint num = llround(cnt[i]);
        ans -= root.pow(i * 2).val * num;
    }

    ans /= 2;
    std::cout << ans << "\n";
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    solve();

    return 0;
}


Measured memory_bytes: 71168