Problem:
Score : 800 points

Problem Statement

Let’s take a prime P = 200\,003.
You are given N integers A_1, A_2, \ldots, A_N.
Find the sum of ((A_i \cdot A_j) \bmod P) over all N \cdot (N-1) / 2 unordered pairs of elements (i < j).

Please note that the sum isn't computed modulo P.

Constraints

2 \leq N \leq 200\,000

0 \leq A_i < P = 200\,003

All values in input are integers.

Input

Input is given from Standard Input in the following format.

N
A_1 A_2 \cdots A_N

Output

Print one integer — the sum over ((A_i \cdot A_j) \bmod P).

Sample Input 1

4
2019 0 2020 200002

Sample Output 1

474287

The non-zero products are:

2019 \cdot 2020 \bmod P = 78320

2019 \cdot 200002 \bmod P = 197984

2020 \cdot 200002 \bmod P = 197983

So the answer is 0 + 78320 + 197984 + 0 + 0 + 197983 = 474287.

Sample Input 2

5
1 1 2 2 100000

Sample Output 2

600013

Solution in C# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

//using System.Numerics;
using CS=System.Runtime.CompilerServices;
using PL=System.Threading.Tasks.Parallel;
//using System.Diagnostics;
using static System.Math;
using ll=System.Int64;
using static Contest_C.Lib_IO;
using static Contest_C.Lib_Minifunc;

using C = System.Int32;
using V = System.Int64;

namespace Contest_C {

public static class Entry
{

	public static void Main() {
		checked{
			long n;
			Lib_IO.rm(out n);
			ll[] a;
			ra(out a);

			List<ll> b = new List<ll>();
			foreach (var e in a)
			{
				if(0<e) b.Add(e);
			}

			ll p = 200003;
			LazySegmentTree<ll,ll> seg = new LazySegmentTree<ll, ll>(b.Count,(x,y)=>x+y,(x,y)=>(x*y)%p,(x,y)=>(x*y)%p,0,1);
			for (int i = 0; i < b.Count; i++)
			{
				seg[i] = b[i];
			}
			seg.Build();

			ll ans = 0;
			for (int i = 0; i < b.Count-1; i++)
			{
				seg.Update(i+1,b.Count,b[i]);
				ans += seg.Query(i+1,b.Count);
				seg.Update(i+1,b.Count,ModInv(b[i], p));				
			}

			wm(ans);
		}
	}

	public static long EGCD(long a, long b, out long x, out long y) {
		x = 0; y = 1;
		long u = 1 , v = 0, gcd = 0;
		while (a != 0) {
			var q = b / a; var r = b % a; var m = x - u * q; var n = y - v * q;
			b = a; a = r; x = u; y = v; u = m; v = n; gcd = b;
		}
		return gcd;
	}

	// 逆元
	public static long ModInv(long value, long modulo) {
		long x, y;
		if (1 != EGCD(value, modulo, out x, out y)) throw new ArgumentException("Invalid modulo", "modulo");
		return (x < 0)?x+modulo:x;
	}
public class LazySegmentTree<TM, TO> where TO: IEquatable<TO>  {
	private int sz, height;
	private TM[] data;
	private TO[] lazy;
	private Func<TM, TM, TM> f;
	private Func<TM, TO, TM> g;
	private Func<TO, TO, TO> h;
	private Func<TO, long, TO> p;
	private TM M1;
	private TO O1;
	public LazySegmentTree(long n, Func<TM, TM, TM> F, Func<TM, TO, TM> G, Func<TO, TO, TO> H, TM M1, TO O1, Func<TO, long, TO> P=null) {
		f = F; g = G; h = H;
		p = (P==null?((x,y)=>x):P);
		this.M1 = M1; this.O1 = O1;
		sz = 1;
		height = 0;
		while(sz < n) {sz <<= 1; height++; }
		data = Enumerable.Repeat(M1, 2 * sz).ToArray();
		lazy = Enumerable.Repeat(O1, 2 * sz).ToArray();
	}
	public TM this[long k] {
		get { return Query(k, k + 1); }
		set { data[k + sz - 1] = value; }
	}
	public void Build() {
		for(int k = sz - 2; k >= 0; k--) {
			data[k] = f(data[2 * k + 1], data[2 * k + 2]);
		}
	}

	private void eval(int k, int len) {
		if(lazy[k].Equals(O1)) return;  // 更新するものが無ければ終了  IEquatable を実装しないとかなり遅くなる。
		if (k < sz - 1) {            // 葉でなければ子に伝搬
			lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
			lazy[2 * k + 2] = h(lazy[2 * k + 2], lazy[k]);
		}
		// 自身を更新
		data[k] = g(data[k], p(lazy[k], len));
		lazy[k] = O1;
	}

	private void Update(long a, long b, TO v, int k, int l, int r ){
		eval(k, r-l);
        if (a <= l && r <= b) {  // 完全に内側の時
            lazy[k] = h(lazy[k], v);
            eval(k, r-l);
        } else if (a < r && l < b) {                     // 一部区間が被る時
            Update(a, b, v, k * 2 + 1, l, (l + r) / 2);  // 左の子
            Update(a, b, v, k * 2 + 2, (l + r) / 2, r);  // 右の子
            data[k] = f(data[k * 2 + 1], data[k * 2 + 2]);
        }
	}
	public void Update(long a, long b, TO v) => Update(a, b, v, 0, 0, sz);

	private TM Query(long a, long b, int k, int l, int r) {
		eval(k, r-l);
        if (r <= a || b <= l) {  // 完全に外側の時
            return M1;
        } else if (a <= l && r <= b) {  // 完全に内側の時
            return data[k];
        } else {  // 一部区間が被る時
            TM vl = Query(a, b, k * 2 + 1, l, (l + r) / 2);
            TM vr = Query(a, b, k * 2 + 2, (l + r) / 2, r);
            return f(vl, vr);
        }
	}
	public TM Query(long a, long b) => Query(a, b, 0, 0, sz);

    public long FindRightest(long a, long b, Func<TM,bool> c) => FindRightest(a, b, c, 0, 0, sz);
    public long FindLeftest(long a, long b, Func<TM,bool> c) => FindLeftest(a, b, c, 0, 0, sz);
    private long FindRightest(long a, long b, Func<TM,bool> c, int k, int l, int r) {
		eval(k, r-l);
        if (!c(data[k]) || r <= a || b <= l) {  // 自分の値が条件を満たさない or [a,b)が[l,r)の範囲外ならreturn a-1
            return a - 1;
        } else if (k >= sz - 1) {  // 自分が葉ならその位置をreturn
            return (k - (sz - 1));
        } else {
            var vr = FindRightest(a, b, c, 2 * k + 2, (l + r) / 2, r);
            if (vr != a - 1) {  // 右の部分木を見て a-1 以外ならreturn
                return vr;
            } else {  // 左の部分木を見て値をreturn
                return FindRightest(a, b, c, 2 * k + 1, l, (l + r) / 2);
            }
        }
    }
    private long FindLeftest(long a, long b, Func<TM,bool> c, int k, int l, int r) {
		eval(k, r-l);
        if (!c(data[k]) || r <= a || b <= l) {  // 自分の値が条件を満たさない or [a,b)が[l,r)の範囲外ならreturn b
            return b;
        } else if (k >= sz - 1) {  // 自分が葉ならその位置をreturn
            return (k - (sz - 1));
        } else {
            var vl = FindLeftest(a, b, c, 2 * k + 1, l, (l + r) / 2);
            if (vl != b) {  // 左の部分木を見て b 以外ならreturn
                return vl;
            } else {  // 右の部分木を見て値をreturn
                return FindLeftest(a, b, c, 2 * k + 2, (l + r) / 2, r);
            }
        }
    }

}






}



#region BaseModule


public static class Lib_Minifunc{
	public const long MOD1 = 1000000007; // 10^9+7
	public const double EPS1 = 1e-8;
	public const long INF1 = 1000000000000000;  // 10^15
	[CS.MethodImpl(256)] public static void swap1<T>(ref T a,ref T b) { T t = a; a = b; b = t; }
	[CS.MethodImpl(256)] public static void swap2<T>(ref T a,ref T b) where T : IComparable { if (a.CompareTo(b)==1) swap1(ref a, ref b); }  // b の方が小さければ交換

	[CS.MethodImpl(256)] public static bool chmin<T>(ref T a,T b) where T : IComparable { bool r; if (r = (a.CompareTo(b)== 1)) a = b; return r; }  // b の方が小さければ a を更新
	[CS.MethodImpl(256)] public static bool chmax<T>(ref T a,T b) where T : IComparable { bool r; if (r = (a.CompareTo(b)==-1)) a = b; return r; }  // b の方が大きければ a を更新
	[CS.MethodImpl(256)] public static bool inside(long i,long n) => (0<=i&&i<n);
	[CS.MethodImpl(256)] public static bool inside(long x,long y,long w,long h) => (inside(x,w)&&inside(y,h));
	[CS.MethodImpl(256)] public static T min<T>(params T[] a) where T : IComparable { T m = a[0]; for (int i=1;i<a.Length;i++) chmin(ref m, a[i]); return m; }
	[CS.MethodImpl(256)] public static T max<T>(params T[] a) where T : IComparable { T m = a[0]; for (int i=1;i<a.Length;i++) chmax(ref m, a[i]); return m; }
	[CS.MethodImpl(256)] public static long mod(long a,long m=MOD1) { var v = a%m; return (v<0?(m<0?v-m:v+m):v); }
	[CS.MethodImpl(256)] public static long ceil(long a,long b) => (a%b==0||(a<0&&0<b)||(0<a&&b<0)?a/b:a/b+1);	// 整数商の切り上げ
	[CS.MethodImpl(256)] public static long round(double a) => Convert.ToInt64(a);	// 四捨五入
	public static string YES(bool a) => a?"YES":"NO";
	public static string yes(bool a) => a?"Yes":"No";
	[CS.MethodImpl(256)] public static P<T,U> initp<T,U>(T a,U b) => new P<T,U>(a,b);
	[CS.MethodImpl(256)] public static P<T,U,V> initp<T,U,V>(T a,U b,V c) => new P<T,U,V>(a,b,c);
	[CS.MethodImpl(256)] public static P<T,U,V,W> initp<T,U,V,W>(T a,U b,V c,W d) => new P<T,U,V,W>(a,b,c,d);
	public static T[] initc<T>(long l1) where T : new() { var m = new T[l1]; PL.For(0, m.Length, i => m[i] = new T() ); return m; }	// new制約は遅い
	public static int[] range(long s, long c) => Enumerable.Range((int)s,(int)c).ToArray();
	[CS.MethodImpl(256)] public static T[] inita<T>(long l1,T v=default(T)) => Enumerable.Repeat(v,(int)l1).ToArray();
	public static T[][] inita<T>(long l1,long l2,T v=default(T)) { var m = new T[l1][]; PL.For(0, m.Length, i => m[i] = inita(l2,v) ); return m; }
	[CS.MethodImpl(256)] public static bool initd<T,U>(this IDictionary<T,U> d, T k, U v=default(U)) { bool f; if(f = !d.ContainsKey(k)) d[k] = v; return f; }
	public static void shift(this IList<int> l,int o) => PL.For(0, l.Count, i => l[i] += o );
	public static void shift(this IList<long> l,long o) => PL.For(0, l.Count, i => l[i] += o );
	public static void shift(this IList<P<int,int>> l,int o1=0,int o2=0) => PL.For(0, l.Count, i => l[i] = new P<int,int>(l[i].A+o1,l[i].B+o2) );
	public static void shift(this IList<P<long,long>> l,long o1=0,long o2=0) => PL.For(0, l.Count, i => l[i] = new P<long,long>(l[i].A+o1,l[i].B+o2) );
	public static void shift(this IList<P<int,int,int>> l,int o1=0,int o2=0,int o3=0) => PL.For(0, l.Count, i => l[i] = new P<int,int,int>(l[i].A+o1,l[i].B+o2,l[i].C+o3) );
	public static void shift(this IList<P<long,long,long>> l,long o1=0,long o2=0,long o3=0) => PL.For(0, l.Count, i => l[i] = new P<long,long,long>(l[i].A+o1,l[i].B+o2,l[i].C+o3) );
	public static void shift(this IList<P<int,int,int,int>> l,int o1=0,int o2=0,int o3=0,int o4=0) => PL.For(0, l.Count, i => l[i] = new P<int,int,int,int>(l[i].A+o1,l[i].B+o2,l[i].C+o3,l[i].D+o4) );
	public static void shift(this IList<P<long,long,long,long>> l,long o1=0,long o2=0,long o3=0,long o4=0) => PL.For(0, l.Count, i => l[i] = new P<long,long,long,long>(l[i].A+o1,l[i].B+o2,l[i].C+o3,l[i].D+o4) );
	public static KeyValuePair<long,T>[] index<T>(this IList<T> l) { var m = new KeyValuePair<long,T>[l.Count]; PL.For(0, l.Count, i => m[i] = new KeyValuePair<long, T>(i,l[i]) ); return m; }
	public static void sort<T>(this T[] a,int o=1, Comparison<T> f=null) where T : IComparable {
		switch(o){
			case  0: Array.Sort(a,f);break;
			case  1: Array.Sort(a,(x,y)=>x.CompareTo(y));break;
			case -1: Array.Sort(a,(x,y)=>y.CompareTo(x));break;
			default: break;
		}
	}
	public static void sort<T,U>(this P<T,U>[] a,int o, Comparison<P<T,U>> f=null) where T : IComparable where U : IComparable {
		switch(o){
			case  0: Array.Sort(a,f);break;
			case  1: Array.Sort(a,(x,y)=>x.A.CompareTo(y.A));break;
			case -1: Array.Sort(a,(x,y)=>y.A.CompareTo(x.A));break;
			case  2: Array.Sort(a,(x,y)=>x.B.CompareTo(y.B));break;
			case -2: Array.Sort(a,(x,y)=>y.B.CompareTo(x.B));break;
			default: break;
		}
	}
	public static void sort<T,U,V>(this P<T,U,V>[] a,int o, Comparison<P<T,U,V>> f=null) where T : IComparable where U : IComparable where V : IComparable {
		switch(o){
			case  0: Array.Sort(a,f);break;
			case  1: Array.Sort(a,(x,y)=>x.A.CompareTo(y.A));break;
			case -1: Array.Sort(a,(x,y)=>y.A.CompareTo(x.A));break;
			case  2: Array.Sort(a,(x,y)=>x.B.CompareTo(y.B));break;
			case -2: Array.Sort(a,(x,y)=>y.B.CompareTo(x.B));break;
			case  3: Array.Sort(a,(x,y)=>x.C.CompareTo(y.C));break;
			case -3: Array.Sort(a,(x,y)=>y.C.CompareTo(x.C));break;
			default: break;
		}
	}
	public static void sort<T,U,V,W>(this P<T,U,V,W>[] a,int o, Comparison<P<T,U,V,W>> f=null) where T : IComparable where U : IComparable where V : IComparable where W : IComparable {
		switch(o){
			case  0: Array.Sort(a,f);break;
			case  1: Array.Sort(a,(x,y)=>x.A.CompareTo(y.A));break;
			case -1: Array.Sort(a,(x,y)=>y.A.CompareTo(x.A));break;
			case  2: Array.Sort(a,(x,y)=>x.B.CompareTo(y.B));break;
			case -2: Array.Sort(a,(x,y)=>y.B.CompareTo(x.B));break;
			case  3: Array.Sort(a,(x,y)=>x.C.CompareTo(y.C));break;
			case -3: Array.Sort(a,(x,y)=>y.C.CompareTo(x.C));break;
			case  4: Array.Sort(a,(x,y)=>x.D.CompareTo(y.D));break;
			case -4: Array.Sort(a,(x,y)=>y.D.CompareTo(x.D));break;
			default: break;
		}
	}
}


public struct P<T,U> {
	public T A; public U B;
	public P(T a,U b) { A = a; B = b; }
	public static implicit operator KeyValuePair<T,U>(P<T,U> a) => new KeyValuePair<T,U>(a.A,a.B);
	public static implicit operator P<T,U>(KeyValuePair<T,U> a) => new P<T,U>(a.Key,a.Value);
}
public struct P<T,U,V> {
	public T A; public U B; public V C;
	public P(T a,U b,V c) { A = a; B = b; C = c; }
}
public struct P<T,U,V,W> {
	public T A; public U B; public V C; public W D;
	public P(T a,U b,V c,W d) { A = a; B = b; C = c; D = d; }
}

public static class Lib_IO {
	class Prt : System.IO.StreamWriter {
		public override IFormatProvider FormatProvider { get { return System.Globalization.CultureInfo.InvariantCulture; } }
		public Prt(System.IO.Stream s) : base(s,new UTF8Encoding(false,true)) {}
		public Prt(System.IO.Stream s,Encoding e) : base(s,e) {}
	}
	static Prt sw = new Prt(Console.OpenStandardOutput());
	static char[] sp = new char[] {' '};
	[CS.MethodImpl(256)] static bool eq<T,U>() => typeof(T).Equals(typeof(U));
	[CS.MethodImpl(256)] static T ct<T,U>(U a) => (T)Convert.ChangeType(a,typeof(T));
	[CS.MethodImpl(256)] static T cv<T>(string s) =>
		eq<T,int>()	? ct<T,int>(int.Parse(s))
	  : eq<T,long>()   ? ct<T,long>(long.Parse(s))
	  : eq<T,double>() ? ct<T,double>(double.Parse(s,System.Globalization.CultureInfo.InvariantCulture))
	  : eq<T,char>()   ? ct<T,char>(s[0])
					   : ct<T,string>(s);
	public static string[] rm<T>(out T a) {
		var z = Console.ReadLine().Split(sp,StringSplitOptions.RemoveEmptyEntries); 
		a = cv<T>(z[0]);
		return z;
	}
	public static string[] rm<T,U>(out T a,out U b) {
		var z = rm<T>(out a); 
		b = cv<U>(z[1]);
		return z;
	}
	public static string[] rm<T,U,V>(out T a,out U b,out V c) {
		var z = rm<T,U>(out a,out b); 
		c = cv<V>(z[2]);
		return z;
	}
	public static string[] rm<T,U,V,W>(out T a,out U b,out V c,out W d) {
		var z = rm<T,U,V>(out a,out b,out c); 
		d = cv<W>(z[3]);
		return z;
	}
	public static string[] rm<T,U,V,W,X>(out T a,out U b,out V c,out W d,out X e) {
		var z = rm<T,U,V,W>(out a,out b,out c,out d); 
		e = cv<X>(z[4]);
		return z;
	}
	public static string[] rm<T,U,V,W,X,Y>(out T a,out U b,out V c,out W d,out X e,out Y f) {
		var z = rm<T,U,V,W,X>(out a,out b,out c,out d,out e); 
		f = cv<Y>(z[5]);
		return z;
	}
	public static string[] ra<T>(out T[] a) {		
		var z = Console.ReadLine().Split(sp,StringSplitOptions.RemoveEmptyEntries);
		a = new T[z.Length];
		for(int i=0;i<a.Length;i++) a[i] = cv<T>(z[i]);
		return z;
	}
	public static string[][] rl<T>(long n,out T[] a) {
		a = new T[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) y[i] = rm(out a[i]);
		return y;
	}
	public static string[][] rl<T,U>(long n,out P<T,U>[] a) {
		a = new P<T,U>[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) {
			T o; U p;
			y[i] = rm(out o,out p);
			a[i] = new P<T,U>(o,p);
		}
		return y;
	}
	public static string[][] rl<T,U,V>(long n,out P<T,U,V>[] a) {
		a = new P<T,U,V>[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) {
			T o; U p; V q;
			y[i] = rm(out o,out p,out q);
			a[i] = new P<T,U,V>(o,p,q);
		}
		return y;
	}
	public static string[][] rl<T,U,V,W>(long n,out P<T,U,V,W>[] a) {
		a = new P<T,U,V,W>[n];
		var y = new string[n][];
		for(int i=0;i<n;i++) {
			T o; U p; V q; W r;
			y[i] = rm(out o,out p,out q,out r);
			a[i] = new P<T,U,V,W>(o,p,q,r);
		}
		return y;
	}
	public static string[][] rx<T>(long n,out T[][] a) {
		a = new T[n][];
		var y = new string[n][];
		for(int i=0;i<n;i++) y[i] = ra(out a[i]);
		return y;
	}

	static void wwp(Action act){
		sw.AutoFlush = false;
		Console.SetOut(sw);
		act();
		Console.Out.Flush();
		sw.AutoFlush = true;
		Console.SetOut(sw);
	}
	[CS.MethodImpl(256)] static string wfm(Type t) =>t.Equals(typeof(double)) ? "{0:F10}" : "{0}";
	public static void wm(params object[] a) {
		wwp(()=>{
			for(int i=0;i<a.Length-1;i++) Console.Write(wfm(a[i].GetType())+" ",a[i]);
			Console.WriteLine(wfm(a[a.Length-1].GetType()),a[a.Length-1]);
		});
	}
	public static void wa<T>(IList<T> a) { wxa(new IList<T>[]{a}, " "); }
	public static void wl<T>(IList<T> a) {
		wwp(()=>{
			var f = wfm(typeof(T));
			if(a.Count==0){
				Console.WriteLine();
			}else{
				foreach(T x in a) Console.WriteLine(f,x);
			}
		});
	}
	static void wxa<T>(IList<IList<T>> a, string s) {
		wwp(()=>{
			var f = wfm(typeof(T));
			var g = f + s;
			foreach(var b in a) {
				if(b.Count==0){
					Console.WriteLine();
				}else{
					for(int i=0;i<b.Count-1;i++) Console.Write(g,b[i]);
					Console.WriteLine(f,b[b.Count-1]);
				}
			}
		});
	}
	public static void wx<T>(IList<IList<T>> a) { wxa(a, " "); }
	public static void wg<T>(IList<IList<T>> a) { wxa(a, ""); }
}

#endregion



}