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

#define REP(i,n) for(ll i=0;i<(ll)n;i++)
#define dump(x)  cerr << "Line " << __LINE__ << ": " <<  #x << " = " << (x) << "\n";
#define spa << " " <<
#define fi first
#define se second
#define ALL(a)  (a).begin(),(a).end()
#define ALLR(a)  (a).rbegin(),(a).rend()

using ld = long double;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<ld, ld>;

template<typename T> using V = vector<T>;
template<typename T> using P = pair<T, T>;
template<typename T> vector<T> make_vec(size_t n, T a) { return vector<T>(n, a); }
template<typename... Ts> auto make_vec(size_t n, Ts... ts) { return vector<decltype(make_vec(ts...))>(n, make_vec(ts...)); }
template<class S, class T> ostream& operator << (ostream& os, const pair<S, T> v){os << "(" << v.first << ", " << v.second << ")"; return os;}
template<typename T> ostream& operator<<(ostream &os, const vector<T> &v) { for (auto &e : v) os << e << ' '; return os; }
template<class T> ostream& operator<<(ostream& os, const vector<vector<T>> &v){ for(auto &e : v){os << e << "\n";} return os;}
struct fast_ios { fast_ios(){ cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;

template <class T> void UNIQUE(vector<T> &x) {sort(ALL(x));x.erase(unique(ALL(x)), x.end());}
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
void fail() { cout << -1 << '\n'; exit(0); }
inline int popcount(const int x) { return __builtin_popcount(x); }
inline int popcount(const ll x) { return __builtin_popcountll(x); }
template<typename T> void debug(vector<vector<T>>&v,ll h,ll w){for(ll i=0;i<h;i++)
{cerr<<v[i][0];for(ll j=1;j<w;j++)cerr spa v[i][j];cerr<<"\n";}};
template<typename T> void debug(vector<T>&v,ll n){if(n!=0)cerr<<v[0];
for(ll i=1;i<n;i++)cerr spa v[i];
cerr<<"\n";};

const ll INF = (1ll<<62);
// const ld EPS   = 1e-10;
// const ld PI    = acos(-1.0);
// const ll mod = (int)1e9 + 7;
//const ll mod = 998244353;

template <int K>
struct FastFourierTransform {
    using cplx = std::complex<double>;
    using cplxs = std::vector<cplx>;
 
    static constexpr double PI = 3.14159265358979323846L;
 
    cplxs zetas;
 
    explicit FastFourierTransform() : zetas(K) {
        for (int i = 0; i < K; ++i) {
            zetas[i] = std::polar(1., 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);
    }
 
    // main routine
    using lint = long long;
    using lints = std::vector<lint>;
 
    lints fft(const lints& ff, const lints& gf) const {
        auto f = li2cp(ff),
             g = li2cp(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 cp2li(h);
    }
 
    // lint <-> complex converter
    cplxs li2cp(const lints& f) const {
        cplxs ret;
        std::transform(f.begin(), f.end(), std::back_inserter(ret),
                       [](auto x) { return cplx(x); });
        return ret;
    }
 
    lints cp2li(const cplxs& f) const {
        lints ret;
        std::transform(f.begin(), f.end(), std::back_inserter(ret),
                       [](auto x) { return std::llround(x.real()); });
        return ret;
    }
};

const FastFourierTransform<20> FFT;

int main(){

    ll N;
    cin >> N;
    V<ll> A;
    REP(i, N){
        ll tmp;
        cin >> tmp;
        if(tmp>0) A.push_back(tmp);
    }
    N = A.size();
    const ll mod = 200003;

    V<ll> R(mod, 0);

    ll now = 1;
    REP(i, mod-1){
        R[now] = i;
        // dump(R[now])
        // dump(now)
        now = (2*now)%mod;
    }

    V<ll> B(N);
    REP(i, N) B[i] = R[A[i]];

    V<ll> H(mod, 0);
    REP(i, N) H[B[i]]++;
    // dump(H[100001])

    auto C = FFT.fft(H, H);
    // dump(C[2*100001])

    ll M = C.size();
    REP(i, N) C[2*B[i]]--;

    // dump(B)

    ll res = 0;
    ll val = 1;
    REP(i, M){
        res += ((C[i]/2) * val);
        val = (2*val)%mod;
    }

    cout << res << endl;

    // dump(B)
    // dump(C)
    //dump((mod-1)*(mod-1)%mod)


    return 0;
}

Measured memory_bytes: 41580