#include<bits/stdc++.h>
#define ll long long
#define int long long
#define fir first
#define sec second
#define pii pair<int,int>
#define isz(v) (int)(v.size())
using namespace std;

const int maxn=200005;
const int inf=0x3f3f3f3f3f3f3f3f;
const int mod=998244353;

namespace Solve {
	struct mint {
		int val;
		mint():val(0) {}
		mint(ll tval) {
			if(-mod<=tval&&tval<2*mod) {
				if(tval>=mod) {
					tval-=mod;
				} 
				if(tval<0) {
					tval+=mod;
				}
			} else {
				tval%=mod;
				if(tval<0) {
					tval+=mod;
				}			
			}
			val=tval;
		}
		mint& operator += (const mint &b) {
			val=val+b.val>=mod?val+b.val-mod:val+b.val;
			return *this;
		}
		mint& operator -= (const mint &b) {
			val=val-b.val<0?val-b.val+mod:val-b.val;
			return *this;
		}
		mint& operator *= (const mint &b) {
			val=1ll*val*b.val>=mod?1ll*val*b.val%mod:val*b.val;
			return *this;
		}
		mint& operator /= (const mint &b) {
			*this*=b.inv();
			return *this;
		}
		friend mint operator + (const mint &a,const mint &b) {
			mint ans=a;
			ans+=b;
			return ans;
		}
		friend mint operator - (const mint &a,const mint &b) {
			mint ans=a;
			ans-=b;
			return ans;
		}
		friend mint operator * (const mint &a,const mint &b) {
			mint ans=a;
			ans*=b;
			return ans;
		}
		friend mint operator / (const mint &a,const mint &b) {
			mint ans=a;
			ans/=b;
			return ans;
		}
		friend bool operator ! (const mint &v) {
			return !v.val;
		}
		friend mint operator - (const mint &v) {
			return mod-v;
		}
		friend mint& operator ++ (mint &v) {
			v+=1;
			return v;
		}
		friend mint operator ++ (mint &v,signed _) {
			mint t=v;
			v+=1;
			return t;
		}
		friend mint& operator -- (mint &v) {
			v-=1; 
			return v;
		}
		friend mint operator -- (mint &v,signed _) {
			mint t=v;
			v-=1;
			return t;
		}
		friend bool operator < (const mint &a,const mint &b) {
			return a.val<b.val;
		}
		friend bool operator == (const mint &a,const mint &b) {
			return a.val==b.val;
		}
		friend bool operator != (const mint &a,const mint &b) {
			return a.val!=b.val;
		}
		friend istream& operator >> (istream &is,mint &x) {
			ll val;
			is>>val;
			x=mint(val); 
			return is;
		}
		friend ostream& operator << (ostream &os,const mint &x) {
			os<<x.val;
			return os;
		}
		mint qpow(ll y) const {
			mint x=*this,ans=1;
			if(y<0) {
				y=-y;
				x=inv();
			}
			while(y) {
				if(y&1) {
					ans*=x;
				} 
				x*=x;
				y>>=1;
			}
			return ans;
		}
		mint inv() const {
			// mod must be a prime
			return qpow(mod-2);
		}
		mint sqrt() {
			mint a=*this; 
			auto check=[&](mint x) {
				return x.qpow((mod-1)/2)==1;
			};
			static mt19937 rnd(73385);
			mint b=rnd()%mod;
			while(check(b*b-a)) {
				b=rnd()%mod;
			}
			static mint val=b*b-a;
			struct Complex {
				mint real,imag;
				Complex(mint treal=0,mint timag=0):real(treal),imag(timag) {}
				Complex operator * (const Complex &rhs) {
					return {real*rhs.real+imag*rhs.imag*val,real*rhs.imag+imag*rhs.real};
				}
				Complex& operator *= (const Complex &rhs) {
					return *this=*this*rhs;
				}
			};
			auto qpow=[&](Complex x,int y) {
				Complex ans={1};
				while(y) {
					if(y&1) {
						ans*=x;
					}
					x*=x;
					y>>=1;
				}
				return ans;
			};
			mint ans=qpow({b,1},(mod+1)/2).real;
			return min(ans,mod-ans);
		}
	};
	mint qpow(mint x,ll y) {
		return x.qpow(y);
	}
	mint inv(mint x) {
		return x.inv();
	}
	struct EA {
		int d,x;
	};
	struct EB {
		int x,y,z;
	};
	struct DSU {
		int fa[maxn];
		int sz[maxn];
		void init(int tn) {
			iota(fa+1,fa+tn+1,1);
			fill(sz+1,sz+tn+1,1);
		}
		int f(int x) {
			return x==fa[x]?x:fa[x]=f(fa[x]);
		}
		bool same(int x,int y) {
			return f(x)==f(y);
		}
		bool merge(int x,int y) {
			x=f(x),y=f(y);
			if(x==y) {
				return false;
			}
			fa[x]=y,sz[y]+=sz[x];
			return true;
		}
		int operator () (const int &x) {
			return f(x);
		}
	} d;
	int n,A,B;
	EA a[maxn];
	EB e[maxn];
	vector<int> ds[maxn];
	vector<array<int,3>> es;
	map<int,int> id;
	mint ans;
	void clear() {
		
	}
	void ckmin(int &x,int y) {
		x=min(x,y);
	}
	int count(int n,vector<int> d) {
		int ans=0;
		while(true) {
			int mi=inf;
			for(int x:d) {
				if(!x) {
					continue;
				}
				ckmin(mi,x);
			}
			if(mi==inf||mi>n) {
				ans+=n;
				break;
			}
			int r;
			if(mi*2>n) {
				r=1;
				ans+=mi*2-n;
			} else {
				r=(n-mi)/mi;
				for(int x:d) {
					if(!x||x==mi) {
						continue;
					}
					ckmin(r,(x-mi)/mi+1);
				}
			}
			n-=mi*r;
			for(int &x:d) {
				if(!x||x==mi) {
					continue;
				}
				x-=mi*r;
			}
		}
		return ans;
	}
	vector<int> useful(int n,vector<int> d) {
		int ans=0;
		vector<int> t=d,u;
		while(true) {
			int mi=inf;
			for(int x:d) {
				if(!x) {
					continue;
				}
				ckmin(mi,x);
			}
			for(int i=0;i<isz(d);i++) {
				if(d[i]==mi) {
					u.push_back(t[i]);
					break;
				}
			}
			if(mi==inf||mi>n) {
				ans+=n;
				break;
			}
			int r;
			if(mi*2>n) {
				r=1;
				ans+=mi*2-n;
			} else {
				r=(n-mi)/mi;
				for(int x:d) {
					if(!x||x==mi) {
						continue;
					}
					ckmin(r,(x-mi)/mi+1);
				}
			}
			n-=mi*r;
			for(int &x:d) {
				if(!x||x==mi) {
					continue;
				}
				x-=mi*r;
			}
		}
		return u;
	}
	vector<int> ask(int n,vector<int> d,vector<int> q) {
		vector<int> ans(isz(q));
		while(true) {
			int mi=inf;
			for(int x:d) {
				if(!x) {
					continue;
				}
				ckmin(mi,x);
			}
			if(mi==inf||mi>n) {
				for(int i=0;i<isz(q);i++) {
					if(!q[i]) {
						continue;
					}
					ans[i]=q[i];
				}
				break;
			}
			int r;
			if(mi*2>n) {
				r=1;
				for(int i=0;i<isz(q);i++) {
					if(!q[i]) {
						continue;
					}
					if(n-mi+1<=q[i]&&q[i]<=mi) {
						ans[i]=q[i];
						q[i]=0;
					}
				}
			} else {
				r=(n-mi)/mi;
				for(int x:d) {
					if(!x||x==mi) {
						continue;
					}
					ckmin(r,(x-mi)/mi+1);
				}
			}
			for(int &x:d) {
				if(!x||x==mi) {
					continue;
				}
				x-=mi*r;
			}
			for(int &x:q) {
				if(!x) {
					continue;
				}
				if(x>n-mi*r) {
					x-=(x-(n-mi*r)+mi-1)/mi*mi;
				}
			}
			n-=mi*r;
		}
		return ans;
	}
	int ask(int n,vector<int> d,int q) {
		return ask(n,d,(vector<int>){q})[0];
	}
	mint calc() {
		int cur=n;
		mint ans;
		for(int i=1;i<=A;i++) {
			ds[i]=ds[i-1];
			ds[i].push_back(a[i].d);
			int c=count(n,ds[i]);
			ans+=mint(cur-c)*a[i].x,cur=c;
			ds[i]=useful(n,ds[i]);
		}
		return ans;
	}
	void solve(int l,int r,vector<int> vs) {
		if(isz(vs)==1) {
			return ;
		}
		if(l==r) {
			for(int i=1;i<isz(vs);i++) {
				ans-=a[l].x;
				es.push_back({a[l].x,id[vs[i-1]],id[vs[i]]});
			}
			return ;
		}
		int mid=(l+r)>>1;
		vector<int> to=ask(n,ds[mid],vs);
		vector<array<int,2>> c;
		for(int i=0;i<isz(vs);i++) {
			c.push_back({to[i],vs[i]});
		}
		sort(c.begin(),c.end());
		vector<int> cur;
		for(int i=0;i<isz(c);i++) {
			int j=i;
			while(j<isz(c)&&c[i][0]==c[j][0]) {
				j++;
			}
			j--;
			cur.push_back(c[i][1]);
			vector<int> d;
			for(int k=i;k<=j;k++) {
				d.push_back(c[k][1]);
			}
			solve(l,mid,d);
			i=j;
		}
		solve(mid+1,r,cur);
	}
	void main(int tid) {
		cin>>n>>A>>B;
		for(int i=1;i<=A;i++) {
			cin>>a[i].d>>a[i].x;
		}
		for(int i=1;i<=B;i++) {
			cin>>e[i].x>>e[i].y>>e[i].z;
		}
		sort(a+1,a+A+1,[&](EA a,EA b) {
			return a.x<b.x;
		});
		ans=calc();
		cerr<<ans<<"\n";
		vector<int> u;
		for(int i=1;i<=B;i++) {
			u.push_back(e[i].x);
			u.push_back(e[i].y);
		}
		sort(u.begin(),u.end());
		u.erase(unique(u.begin(),u.end()),u.end());
		for(int i=0;i<isz(u);i++) {
			id[u[i]]=i+1;
		}
		solve(1,A,u);
		for(int i=1;i<=B;i++) {
			es.push_back({e[i].z,id[e[i].x],id[e[i].y]});
		}
		sort(es.begin(),es.end());
		d.init(isz(u));
		for(auto p:es) {
			if(d.same(p[1],p[2])) {
				continue;
			}
			ans+=p[0];
			d.merge(p[1],p[2]);
		}
		cout<<ans<<"\n";
	}
	void init() {
		
	}
}

signed main() {
#ifndef ONLINE_JUDGE
	freopen("mst.in","r",stdin);
	freopen("mst.out","w",stdout);
#endif
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	int T=1;
//	cin>>T;
	Solve::init();
	for(int t=1;t<=T;t++) {
		Solve::main(t);
		Solve::clear();
	}
}