#include <bits/stdc++.h>

const int N = 5e5 + 50;
typedef long long ll;
typedef unsigned long long ull;
int n, m;
int64_t x, y, z, p[N];
std::unordered_map<uint64_t, bool> map;

struct node
{
	int id;
	node* prv, * nxt;
} nodes[N];

std::set<node*> set;

inline ull id(int x, int y)
{
	return 1ull * x * n + y;
}

inline bool col(int a, int b)
{
	if (a > b) std::swap(a, b);
	if (map.count(id(a, b))) return map[id(a, b)];
	return (a * x + b * y) % z >= p[a] + p[b];
}

inline bool bug(node* p)
{
	return col(p->id, p->prv->id) != col(p->id, p->nxt->id);
}

inline void erase(node* p)
{
	p->prv->nxt = p->nxt;
	p->nxt->prv = p->prv;
}
bool solve(node* p)
{
	if (p->prv->id == p->nxt->id)
	{
		printf("%d %d\n", p->id, p->prv->id);
		return col(p->id, p->prv->id);
	}
	else if (set.empty())
	{
		node* q = p->nxt;
		while (q != p) printf("%d %d\n", q->id, q->nxt->id), q = q->nxt;
		return col(p->id, p->nxt->id);
	}
	else
	{
		node* q = *set.begin(); set.erase(q);
		int u0, v0, u1, v1;
		if (col(q->id, q->prv->id) == 0)
		{
			u0 = q->id, v0 = q->prv->id;
			u1 = q->id, v1 = q->nxt->id;
		}
		else
		{
			u0 = q->id, v0 = q->nxt->id;
			u1 = q->id, v1 = q->prv->id;
		} 
		erase(q);
		if (bug(q->prv)) set.emplace(q->prv);
		else if (set.find(q->prv) != set.end()) set.erase(q->prv);
		if (bug(q->nxt)) set.emplace(q->nxt);
		else if (set.find(q->nxt) != set.end()) set.erase(q->nxt);
		int t = solve(q->nxt);
		if (t == 0) printf("%d %d\n", u0, v0);
		else printf("%d %d\n", u1, v1);
		return t;
	}
}

inline char nc()
{
	static char buf[1000000], * p1 = buf, * p2 = buf;
	return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;
}

inline int64_t read()
{
	int64_t res = 0;
	char ch;
	do ch = nc(); while (ch < 48 || ch > 57);
	do res = res * 10 + ch - 48, ch = nc(); while (ch >= 48 && ch <= 57);
	return res;
}

int main()
{
	n = read(), m = read();
	for (int i = 0; i < m; ++i)
	{
		int x = read(), y = read(), z = read();
		if (x > y) std::swap(x, y);
		map[id(x, y)] = z;
	}
	x = read(), y = read(), z = read();
	for (int i = 1; i <= n; ++i) p[i] = read(); 
	for (int i = 1; i <= n; ++i) nodes[i].id = i, nodes[i].prv = &nodes[i - 1], nodes[i].nxt = &nodes[i + 1];
	nodes[1].prv = &nodes[n], nodes[n].nxt = &nodes[1];
	for (int i = 1; i <= n; ++i) if (bug(&nodes[i])) set.emplace(&nodes[i]);
	solve(&nodes[1]);
	return 0;
}