Problem:
Score : 700 points

Problem Statement

Squid loves painting vertices in graphs.

There is a simple undirected graph consisting of N vertices numbered 1 through N, and M edges.
Initially, all the vertices are painted in color 0. The i-th edge bidirectionally connects two vertices a_i and b_i. The length of every edge is 1.

Squid performed Q operations on this graph. In the i-th operation, he repaints all the vertices within a distance of d_i from vertex v_i, in color c_i.

Find the color of each vertex after the Q operations.

Constraints

1 ≤ N,M,Q ≤ 10^5

1 ≤ a_i,b_i,v_i ≤ N

a_i ≠ b_i

0 ≤ d_i ≤ 10

1 ≤ c_i ≤10^5

d_i and c_i are all integers.

There are no self-loops or multiple edges in the given graph.

Partial Score

200 points will be awarded for passing the testset satisfying 1 ≤ N,M,Q ≤ 2{,}000.

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1
:
a_{M} b_{M}
Q
v_1 d_1 c_1
:
v_{Q} d_{Q} c_{Q}

Output

Print the answer in N lines.
In the i-th line, print the color of vertex i after the Q operations.

Sample Input 1

7 7
1 2
1 3
1 4
4 5
5 6
5 7
2 3
2
6 1 1
1 2 2

Sample Output 1

2
2
2
2
2
1
0

Initially, each vertex is painted in color 0.
In the first operation, vertices 5 and 6 are repainted in color 1.
In the second operation, vertices 1, 2, 3, 4 and 5 are repainted in color 2.

Sample Input 2

14 10
1 4
5 7
7 11
4 10
14 7
14 3
6 14
8 11
5 13
8 3
8
8 6 2
9 7 85
6 9 3
6 7 5
10 3 1
12 9 4
9 6 6
8 2 3

Sample Output 2

1
0
3
1
5
5
3
3
6
1
3
4
5
3

The given graph may not be connected.

Solution in C (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include<stdio.h>
#include<stdlib.h>

#define N_MAX 100000
#define M_MAX 100000
#define Q_MAX 100000

typedef struct tag_edge_t
{
	int from, to;
	struct tag_edge_t *next;
}edge_t;

typedef struct
{
	int id, c, x, d, y;
	edge_t *edge;
}node_t;

typedef struct
{
	int v, d, c, x;
}cmd_t;


#define QUE_SIZE Q_MAX*10

node_t node[N_MAX+1];
edge_t edge[M_MAX*2];
cmd_t cmd[Q_MAX];
cmd_t que[QUE_SIZE];
int que_start, que_end;

void que_init(void)
{
	que_start=que_end=0;
}

int que_push(cmd_t cmd)
{
	que[(que_end++)%QUE_SIZE]=cmd;
	if(que_end>=que_start+QUE_SIZE)
	{
		printf("que_start=%d\n", que_start);
		printf("que_end=%d\n", que_end);
		exit(1);
	}
	return 1;
}


int que_pop(cmd_t *cmd)
{
	if(que_end<=que_start) return 0;

	*cmd=que[(que_start++)%QUE_SIZE];
	if(que_start>=QUE_SIZE)
	{
		que_start-=QUE_SIZE;
		que_end-=QUE_SIZE;
	}
	return 1;
}


void paint(cmd_t cmd)
{
	edge_t *edge;
	cmd_t cmd2;

	que_init();
	que_push(cmd);
	while(que_pop(&cmd))
	{
		if(node[cmd.v].x==cmd.x) continue;

		if(node[cmd.v].x<cmd.x)
		{
			node[cmd.v].c=cmd.c;
			node[cmd.v].x=cmd.x;
			node[cmd.v].d=cmd.d;
		}
		else
		{
			if(node[cmd.v].d>=cmd.d) continue;
		}

		if(cmd.d<1) continue;

		cmd2=cmd;
		cmd2.d--;
		edge=node[cmd.v].edge;
		for(;edge;edge=edge->next)
		{
			if(node[edge->to].x==cmd.x) continue;
			if(node[edge->to].y==cmd.x) continue;
			cmd2.v=edge->to;
			node[edge->to].y=cmd.x;
			que_push(cmd2);
		}
	}
//	printf("\n");
}


int cmp(const void *pa, const void *pb)
{
	const cmd_t *a, *b;
	a=pa;
	b=pb;
	if(a->d>b->d) return -1;
	return a->d<b->d;
}


int cmp2(const void *pa, const void *pb)
{
	const cmd_t *a, *b;
	a=pa;
	b=pb;
	if(a->d<b->d) return -1;
	return a->d>b->d;
}


int main(void)
{
	int N, M, Q;
	int a, b;
	int i;

	while(scanf("%d%d", &N, &M)==2)
	{
		for(i=1;i<=N;i++)
		{
			node[i].id=i;
			node[i].c=0;
			node[i].edge=NULL;
			node[i].x=-1;
			node[i].y=-1;
		}
		for(i=0;i<M;i++)
		{
			scanf("%d%d", &a, &b);
			edge[i*2  ].next=node[a].edge;
			edge[i*2  ].from=a;
			edge[i*2  ].to=b;
			node[a].edge=&edge[i*2  ];
			edge[i*2+1].next=node[b].edge;
			edge[i*2+1].from=b;
			edge[i*2+1].to=a;
			node[b].edge=&edge[i*2+1];
		}
		scanf("%d", &Q);
		for(i=0;i<Q;i++)
		{
			scanf("%d%d%d", &cmd[i].v, &cmd[i].d, &cmd[i].c);
			cmd[i].x=i;
		}
//		qsort(cmd, Q, sizeof(cmd_t), cmp2);
//		for(i=0;i<Q;i++) printf("cmd %d,%d,%d,%d\n", cmd[i].v, cmd[i].d, cmd[i].c, cmd[i].x);
		for(i=Q-1;i>=0;i--)
		{
			paint(cmd[i]);
		}
		for(i=1;i<=N;i++) printf("%d\n", node[i].c);
	}

	return 0;
}