#pragma once
#include<cstdio>
#define unlikely(x)     __builtin_expect(!!(x), 0)
struct char_reader
{
        FILE* f; char *buf,*p1,*p2; int size;
        char_reader(FILE* fin,int bufsize=1<<16) { f=fin; size=bufsize; p1=p2=0; buf=new char[size]; }
        ~char_reader() { delete []buf; }
        inline int operator()() { return p1==p2&&(p2=(p1=buf)+fread(buf,1,size,f),p1==p2)?EOF:*p1++; }
};
struct char_writer
{
        FILE* f; char *buf,*p,*end; int size;
        char_writer(FILE* fout,int bufsize=1<<16) { f=fout; size=bufsize; buf=new char[size]; p=buf; end=buf+bufsize; }
        ~char_writer() { fwrite(buf,p-buf,1,f); delete []buf; }
        inline char operator()(char ch)
        {
                if(unlikely(end==p)) { fwrite(buf,end-buf,1,f); p=buf; }
                return *p++=ch;
        }
};
char_reader gch(stdin);
char_writer wch(stdout);
template<typename T> inline int read(T& t)
{
        bool f=false; int ch; while(ch=gch(),!((ch>='0'&&ch<='9')||ch=='-')) { if(ch==EOF) return 0; }
        t=0;
        if(ch=='-') f=true,ch=gch(); t=ch^48; while(ch=gch(),ch>='0'&&ch<='9') t=(t<<3)+(t<<1)+(ch^48);
        if(f) t=-t;
        return 1;
}
inline int read(char &c)
{
        c=0; int ch; while(ch=gch(),(ch==' '||ch=='\n'||ch=='\r'||ch=='\t')) { if(ch==EOF) return 0; } c=ch;
        return 1;
}
inline int read(char *s)
{
        int ch; while(ch=gch(),(ch==' '||ch=='\n'||ch=='\r'||ch=='\t')) { if(ch==EOF) return 0; }
        *s++=ch; while(ch=gch(),!(ch==' '||ch=='\n'||ch=='\r'||ch=='\t')&&ch!=EOF) *s++=ch;
        return 1;
} inline int read(const char *s) { return read((char*)s); }
inline int readline(char *s)
{
        int ch; while(ch=gch(),(ch==' '||ch=='\n'||ch=='\r'||ch=='\t')) { if(ch==EOF) return 0; }
        *s++=ch; while(ch=gch(),!(ch=='\n'||ch=='\r')&&ch!=EOF) *s++=ch;
        return 1;
} inline int readline(const char *s) { return readline((char*)s); }
template<typename T> inline void write(T t)
{
        int stk[20],cnt=0;
        if(t==0) { wch('0'); return; } if(t<0) { wch('-'); t=-t; }
        while(t>0) { stk[cnt++]=t%10; t/=10; } while(cnt) wch(stk[--cnt]+'0');
}
inline void write(char t) { wch(t); }
inline void write(char *s) { while(*s) wch(*s++); } inline void write(const char *s) { write((char*)s); }
#if __cplusplus >= 201103L
template<typename T,typename... Args> inline int read(T& t,Args&... args) { return read(t)+read(args...); }
template<typename T,typename... Args> inline void write(T t,Args... args) { write(t); write(args...); }
#else
template<typename A_t,typename B_t> inline int read(A_t &a,B_t &b) { return read(a)+read(b); }
template<typename A_t,typename B_t,typename C_t> inline int read(A_t &a,B_t &b,C_t &c) { return read(a)+read(b)+read(c); }
template<typename A_t,typename B_t,typename C_t,typename D_t> inline int read(A_t &a,B_t &b,C_t &c,D_t &d) { return read(a)+read(b)+read(c)+read(d); }
template<typename A_t,typename B_t> inline void write(A_t a,B_t b) { write(a); write(b); }
template<typename A_t,typename B_t,typename C_t> inline void write(A_t a,B_t b,C_t c) { write(a); write(b); write(c); }
template<typename A_t,typename B_t,typename C_t,typename D_t> inline void write(A_t a,B_t b,C_t c,D_t d) { write(a); write(b); write(c); write(d); }
#endif
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#include<cassert>
using namespace std;
typedef long long LL;
const int maxn=1e5+10;
const int maxm=5e5+10;
const int maxw=1e5+10;
struct DSUType
{
	int fa[maxn],size[maxn];
	void init(int n)
	{
		for(int i=1;i<=n;i++)
		{
			fa[i]=i;
			size[i]=1;
		}
	}
	inline int GetRoot(int u)
	{
		int rt=u,x;
		while(fa[rt]!=rt) rt=fa[rt];
		while(u!=rt)
		{
			x=fa[u];
			fa[u]=rt;
			u=x;
		}
		return rt;
	}
	inline void Merge(int a,int b)
	{
		a=GetRoot(a);
		b=GetRoot(b);
		if(size[a]<size[b]) swap(a,b);
		fa[b]=a;
		size[a]+=size[b];
	}
} DSU;
struct RawEdge
{
	int u,v,w;
};
inline bool operator<(const RawEdge &a,const RawEdge &b) { return a.w>b.w; }
struct Edge
{
	int v,w;
	Edge *nxt;
}mem[maxm*2],*G[maxn],*ecnt=mem;
inline void AddEdge(int u,int v,int w)
{
	ecnt->v=v;
	ecnt->w=w;
	ecnt->nxt=G[u];
	G[u]=ecnt++;
}
int n,m;
bool vis[maxn];
vector<RawEdge> rawG;
int root[maxn],dep[maxn],anc[maxn][25],min_up[maxn][25];
void InitData(int p,int fa)
{
	vis[p]=true;
	dep[p]=dep[fa]+1;
	for(int i=1;i<25;i++) anc[p][i]=anc[anc[p][i-1]][i-1];
	for(int i=1;i<25;i++) min_up[p][i]=min(min_up[p][i-1],min_up[anc[p][i-1]][i-1]);
	for(Edge *it=G[p];it;it=it->nxt)
		if(it->v!=fa)
		{
			min_up[it->v][0]=it->w;
			anc[it->v][0]=p;
			InitData(it->v,p);
		}
}
inline int GetLCA(int x,int y)
{
	if(x==y) return x;
	if(dep[y]>dep[x]) swap(x,y);
	for(int i=24;i>=0;i--)
		if(dep[anc[x][i]]>=dep[y])
			x=anc[x][i];
	assert(dep[x]==dep[y]);
	if(x==y) return x;
	for(int i=24;i>=0;i--)
		if(anc[x][i]!=anc[y][i])
		{
			x=anc[x][i];
			y=anc[y][i];
		}
	return anc[x][0];
}
inline int GetRoute(int x,int rt)
{
	int res=0x3f3f3f3f,len=dep[x]-dep[rt];
	for(int i=24;i>=0;i--)
		if(len&(1<<i))
		{
			res=min(res,min_up[x][i]);
			x=anc[x][i];
		}
	return res;
}
int main()
{
#ifdef local
	freopen("pro.in","r",stdin);
#endif
	read(n,m);
	for(int i=0;i<m;i++)
	{
		int u,v,w; read(u,v,w);
		rawG.push_back(RawEdge({u,v,w}));
	}
	sort(rawG.begin(),rawG.end());
	DSU.init(n);
	for(int i=0;i<rawG.size();i++)
	{
		int u=rawG[i].u,v=rawG[i].v,w=rawG[i].w;
		u=DSU.GetRoot(u);
		v=DSU.GetRoot(v);
		if(u==v) continue;
		DSU.Merge(u,v);
		AddEdge(u,v,w);
		AddEdge(v,u,w);
	}
	for(int i=1;i<=n;i++) root[i]=DSU.GetRoot(i);
	memset(min_up,0x3f,sizeof(min_up));
	for(int i=1;i<=n;i++)
		if(!vis[i])
			InitData(root[i],0);
	LL final_res=0;
	int q; read(q);
	for(int i=1;i<=q;i++)
	{
		int x,y; read(x,y);
		if(root[x]!=root[y]) continue;
		int lca=GetLCA(x,y);
		final_res^=LL(i)*min(GetRoute(x,lca),GetRoute(y,lca));
	}
	printf("%lld\n",final_res);
	return 0;
}