有着美丽高贵火车头和 fio 快读的代码。

#include <bits/stdc++.h>
#define int long long
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)

using namespace std;

struct ios {
    inline char read() {
        static const int inlen = 1 << 18 | 1;
        static char buf[inlen], *s, *t;
        return (s == t) && (t = (s = buf) + fread(buf, 1, inlen, stdin)), s == t ? -1 : *s++;
    }
    template<typename T> inline ios& operator>> (T &x) {
        static char c11, boo;
        for (c11 = read(), boo = 0; !isdigit(c11); c11 = read()) {
            if (c11 == -1) return *this;
            boo |= c11 == '-';
        }
        for (x = 0; isdigit(c11); c11 = read()) x = x * 10 + (c11 ^ '0');
        boo && (x = -x);
        return *this;
    }
} fin;

struct exios {
    template<typename _CharT, typename _Traits = char_traits<_CharT>>
    struct typ {
        typedef basic_ostream<_CharT, _Traits>& (* end) (basic_ostream<_CharT, _Traits>&);
    };

    template<typename T> friend exios &operator<<(exios &out, T num) {
        if (num < 0) putchar('-'), num = -num;
        if (num >= 10) out << num / 10;
        putchar(num % 10 + '0');
        return out;
    }

    friend exios &operator<<(exios &out, const char * s) { printf("%s", s); return out; }
    friend exios &operator<<(exios &out, string s) { cout << s; return out; }
    friend exios &operator<<(exios &out, typ<char>::end e) { puts(""); return out; }
} fout;

const int maxn = 5e1 + 10;
const int maxm = 3e2 + 10;
const int inf = 1e12;

struct edge {
	int u, v, w;
};

int n, m, p, k, A, B, C, ans;
edge e[maxm];
int b[maxm * maxm * 3], cnt;
vector<int> con[maxm * maxm * 3];
vector<int> pre[maxm * maxm * 3];
int fa[maxn];

int find(int x) {
	return x == fa[x] ? x : fa[x] = find(fa[x]);
}

int sum(int i, int l, int r) {
	int vl = l ? pre[i][l - 1] : 0;
	return pre[i][r] - vl;
}

signed main() {
	fin >> n >> m;
	for (int i = 1; i <= m; i++) fin >> e[i].u >> e[i].v >> e[i].w;
	for (int i = 1; i <= m; i++) {
		for (int j = i + 1; j <= m; j++) {
			b[++cnt] = (e[i].w + e[j].w) >> 1;
		}
	}
	b[++cnt] = inf;
	sort(b + 1, b + 1 + cnt);
	cnt = unique(b + 1, b + 1 + cnt) - b - 1;
	for (int i = 1; i <= cnt; i++) {
		for (int j = 1; j <= n; j++) fa[j] = j;
		sort(e + 1, e + 1 + m, [=] (edge x, edge y) {
			int xw = abs(x.w - b[i]), yw = abs(y.w - b[i]);
			return xw == yw ? x.w < y.w : xw < yw;
		});
		int cur = 0;
		for (int j = 1; j <= m; j++) {
			int u = find(e[j].u), v = find(e[j].v);
			if (u != v) {
				++cur;
				fa[u] = v;
				con[i].push_back(e[j].w);
			}
			if (cur == n - 1) break;
		}
		sort(con[i].begin(), con[i].end());
		pre[i].push_back(con[i][0]);
		for (int j = 1; j < con[i].size(); j++) pre[i].push_back(pre[i][j - 1] + con[i][j]);
	}
	fin >> p >> k >> A >> B >> C;
	int lst = 0;
	for (int i = 1, q; i <= k; i++) {
		if (i <= p) fin >> q;
		else q = (lst % C * (A % C) % C + B % C) % C;
		lst = q;
		int j = lower_bound(b + 1, b + 1 + cnt, q) - b;
		int y = lower_bound(con[j].begin(), con[j].end(), q) - con[j].begin();
		int v1 = sum(j, y, con[j].size() - 1) - q * (con[j].size() - y);
		int v2 = q * y - (y ? sum(j, 0, y - 1) : 0);
		ans ^= (v1 + v2);
	}
	fout << ans << endl;
	return 0;
}