Egor is a famous Russian singer, rapper, actor and blogger, and finally he decided to give a concert in the sunny Republic of Dagestan.

There are $n$ cities in the republic, some of them are connected by $m$ directed roads without any additional conditions. In other words, road system of Dagestan represents an arbitrary directed graph. Egor will arrive to the city $1$, travel to the city $n$ by roads along some path, give a concert and fly away.

As any famous artist, Egor has lots of haters and too annoying fans, so he can travel only by safe roads. There are two types of the roads in Dagestan, black and white: black roads are safe at night only, and white roads — in the morning. Before the trip Egor's manager's going to make a schedule: for each city he'll specify it's color, black or white, and then if during the trip they visit some city, the only time they can leave it is determined by the city's color: night, if it's black, and morning, if it's white. After creating the schedule Egor chooses an available path from $1$ to $n$, and for security reasons it has to be the shortest possible.

Egor's manager likes Dagestan very much and wants to stay here as long as possible, so he asks you to make such schedule that there would be no path from $1$ to $n$ or the shortest path's length would be greatest possible.

A path is one city or a sequence of roads such that for every road (excluding the first one) the city this road goes from is equal to the city previous road goes into. Egor can move only along paths consisting of safe roads only. 

The path length is equal to the number of roads in it. The shortest path in a graph is a path with smallest length.


-----Input-----

The first line contains two integers $n$, $m$ ($1 \leq n \leq 500000$, $0 \leq m \leq 500000$) — the number of cities and the number of roads.

The $i$-th of next $m$ lines contains three integers — $u_i$, $v_i$ and $t_i$ ($1 \leq u_i, v_i \leq n$, $t_i \in \{0, 1\}$) — numbers of cities connected by road and its type, respectively ($0$ — night road, $1$ — morning road).


-----Output-----

In the first line output the length of the desired path (or $-1$, if it's possible to choose such schedule that there's no path from $1$ to $n$).

In the second line output the desired schedule — a string of $n$ digits, where $i$-th digit is $0$, if the $i$-th city is a night one, and $1$ if it's a morning one.

If there are multiple answers, print any.


-----Examples-----
Input
3 4
1 2 0
1 3 1
2 3 0
2 3 1

Output
2
011
Input
4 8
1 1 0
1 3 0
1 3 1
3 2 0
2 1 0
3 4 1
2 4 0
2 4 1

Output
3
1101
Input
5 10
1 2 0
1 3 1
1 4 0
2 3 0
2 3 1
2 5 0
3 4 0
3 4 1
4 2 1
4 5 0

Output
-1
11111


-----Note-----

For the first sample, if we paint city $1$ white, the shortest path is $1 \rightarrow 3$. Otherwise, it's $1 \rightarrow 2 \rightarrow 3$ regardless of other cities' colors.

For the second sample, we should paint city $3$ black, and there are both black and white roads going from $2$ to $4$. Note that there can be a road connecting a city with itself.

Difficulty: MEDIUM

Starter code:

Solutions:
import sys
input = sys.stdin.readline
(N, M) = map(int, input().split())
d = [set() for _ in range(N + 1)]
for _ in range(M):
	(u, v, t) = map(int, input().split())
	d[v].add((u, t))
s = [-1] * (N + 1)
s[N] = 1
from collections import deque
queue = deque([N])
vs = set([N])
dist = [0] * (N + 1)
while queue:
	v = queue.popleft()
	for (u, t) in d[v]:
		if u in vs:
			continue
		if s[u] == -1:
			s[u] = 1 - t
			continue
		if s[u] != t:
			continue
		vs.add(u)
		queue.append(u)
		dist[u] = dist[v] + 1
R = dist[1]
if N != 1:
	print(R if R else -1)
	for i in range(N + 1):
		if s[i] == -1:
			s[i] = 0
	print(''.join((str(c) for c in s[1:])))
else:
	print(0)
	print('1')


from sys import stdin
(n, m) = map(int, stdin.readline().split())
lis = [[] for i in range(n)]
for i in range(m):
	(u, v, t) = map(int, stdin.readline().split())
	u -= 1
	v -= 1
	lis[v].append((u, t))
from collections import deque
q = deque([n - 1])
c = [None] * n
d = [float('inf')] * n
d[n - 1] = 0
c[n - 1] = 0
while len(q) > 0:
	v = q.popleft()
	for (nex, vc) in lis[v]:
		if c[nex] == None:
			c[nex] = vc ^ 1
		elif c[nex] == vc and d[nex] > d[v] + 1:
			d[nex] = d[v] + 1
			q.append(nex)
for i in range(n):
	if c[i] == None:
		c[i] = 0
if d[0] == float('inf'):
	print(-1)
else:
	print(d[0])
print(''.join(map(str, c)))


import sys
input = sys.stdin.readline
from collections import deque
G = list()
vis = []
col = []
dis = []

def bfs(s):
	q = deque([s])
	q.append(s)
	vis = [0] * (s + 1)
	col = [-1] * (s + 1)
	dis = [1061109567] * (s + 1)
	col[s] = 0
	dis[s] = 0
	while q:
		v = q.popleft()
		vis[v] = 1
		for (u, w) in G[v]:
			if vis[u]:
				continue
			if col[u] == -1:
				col[u] = 1 - w
			elif col[u] == w and dis[u] > dis[v] + 1:
				dis[u] = dis[v] + 1
				q.append(u)
	if dis[1] == 1061109567:
		print(-1)
	else:
		print(dis[1])
	for i in range(1, s + 1):
		print(max(col[i], 0), end='')

def main():
	(n, m) = map(int, input().split())
	for i in range(int(n) + 1):
		G.append([])
	for i in range(m):
		(u, v, w) = map(int, input().split())
		G[v].append((u, w))
	bfs(n)
main()


import sys
sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]
from heapq import *
inf = 10 ** 9
(n, m) = MI()
to = [[] for _ in range(n)]
ot = [[] for _ in range(n)]
for _ in range(m):
	(u, v, t) = MI()
	(u, v) = (u - 1, v - 1)
	to[u].append((v, t))
	ot[v].append((u, t))
dp = [inf] * n
dp[n - 1] = 0
ans = [-1] * n
hp = []
heappush(hp, (0, n - 1))
while hp:
	(d, u) = heappop(hp)
	if d > dp[u]:
		continue
	for (v, t) in ot[u]:
		if dp[v] != inf:
			continue
		if ans[v] == t and dp[v] > d + 1:
			dp[v] = d + 1
			heappush(hp, (d + 1, v))
		if ans[v] == -1:
			ans[v] = 1 - t
for u in range(n):
	if ans[u] == -1:
		ans[u] = 1
print(-1 if dp[0] == inf else dp[0])
print(*ans, sep='')


import sys
from math import ceil, gcd
from collections import deque
input = sys.stdin.buffer.readline
(n, m) = [int(i) for i in input().split()]
adj = [[] for i in range(n + 1)]
mark = [0] * (n + 1)
d = [-1] * (n + 1)
c = [-1] * (n + 1)
for i in range(m):
	(u, v, b) = [int(i) for i in input().split()]
	adj[v].append((u, b))
q = deque()
q.append(n)
d[n] = 0
mark[n] = 1
while q:
	f = q.popleft()
	for i in adj[f]:
		if mark[i[0]] == 0:
			if c[i[0]] == -1:
				if i[1] == 1:
					c[i[0]] = 0
				else:
					c[i[0]] = 1
			elif c[i[0]] == i[1]:
				d[i[0]] = d[f] + 1
				q.append(i[0])
				mark[i[0]] = 1
sys.stdout.write(str(d[1]))
sys.stdout.write('\n')
for i in range(1, n + 1):
	if c[i] == -1:
		sys.stdout.write(str(1))
	else:
		sys.stdout.write(str(c[i]))
sys.stdout.write('\n')


import sys
input = sys.stdin.readline
from collections import deque
(n, m) = list(map(int, input().split()))
back = [[] for i in range(n)]
for _ in range(m):
	(u, v, w) = list(map(int, input().split()))
	u -= 1
	v -= 1
	back[v].append((u, w))
out = [2] * n
outl = [-1] * n
outl[-1] = 0
q = deque([n - 1])
while q:
	v = q.popleft()
	for (u, w) in back[v]:
		if out[u] != w:
			out[u] = 1 - w
		elif outl[u] == -1:
			outl[u] = outl[v] + 1
			q.append(u)
out = [v if v != 2 else 1 for v in out]
print(outl[0])
print(''.join(map(str, out)))


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(n, m) = map(int, input().split())
inverseAdjacencyList = []
color = [-1] * n
for _ in range(n):
	inverseAdjacencyList.append([])
for _ in range(m):
	(u, v, t) = map(int, input().split())
	if u != v:
		inverseAdjacencyList[v - 1].append((u - 1, t))
for i in range(n):
	inverseAdjacencyList[i].sort()
distance = [-1] * n
distance[n - 1] = 0
bfsQueue = [n - 1]
bfsQueueIndex = 0
while len(bfsQueue) > bfsQueueIndex:
	curElem = bfsQueue[bfsQueueIndex]
	bfsQueueIndex += 1
	i = 0
	while i < len(inverseAdjacencyList[curElem]):
		elemConsidered = inverseAdjacencyList[curElem][i][0]
		if distance[elemConsidered] != -1:
			i += 1
			continue
		if color[elemConsidered] == inverseAdjacencyList[curElem][i][1]:
			bfsQueue.append(elemConsidered)
			distance[elemConsidered] = distance[curElem] + 1
		else:
			color[elemConsidered] = 1 - inverseAdjacencyList[curElem][i][1]
		i += 1
for i in range(n):
	if color[i] == -1:
		color[i] = 0
print(distance[0])
print(''.join(map(str, color)))


import sys
input = sys.stdin.readline
(n, m) = map(int, input().split())
EDGE_inv = [dict() for i in range(n + 1)]
for i in range(m):
	(u, v, t) = map(int, input().split())
	if u == v:
		continue
	if u in EDGE_inv[v]:
		if EDGE_inv[v][u] == t:
			continue
		else:
			EDGE_inv[v][u] = 2
	else:
		EDGE_inv[v][u] = t
import heapq
H = [(0, n)]
DIST = [1 << 30] * (n + 1)
DIST[n] = 0
ANS = [-1] * (n + 1)
while H:
	(dist, ind) = heapq.heappop(H)
	for fr in EDGE_inv[ind]:
		if EDGE_inv[ind][fr] == 2:
			if DIST[fr] > DIST[ind] + 1:
				DIST[fr] = DIST[ind] + 1
				heapq.heappush(H, (DIST[fr], fr))
		else:
			nd = EDGE_inv[ind][fr]
			if ANS[fr] != nd:
				ANS[fr] = 1 - nd
			elif DIST[fr] > DIST[ind] + 1:
				DIST[fr] = DIST[ind] + 1
				heapq.heappush(H, (DIST[fr], fr))
ALIST = []
for i in range(1, n + 1):
	if ANS[i] == 1:
		ALIST.append(1)
	else:
		ALIST.append(0)
if DIST[1] == 1 << 30:
	print(-1)
else:
	print(DIST[1])
print(''.join(map(str, ALIST)))


import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]
from collections import deque
inf = 10 ** 9
(n, m) = MI()
ot = [[] for _ in range(n)]
for _ in range(m):
	(u, v, t) = MI()
	(u, v) = (u - 1, v - 1)
	ot[v].append((u, t))
dp = [inf] * n
dp[n - 1] = 0
ans = [-1] * n
q = deque()
q.append((0, n - 1))
while q:
	(d, u) = q.popleft()
	if d > dp[u]:
		continue
	for (v, t) in ot[u]:
		if dp[v] != inf:
			continue
		if ans[v] == t and dp[v] > d + 1:
			dp[v] = d + 1
			q.append((d + 1, v))
		if ans[v] == -1:
			ans[v] = 1 - t
for u in range(n):
	if ans[u] == -1:
		ans[u] = 1
print(-1 if dp[0] == inf else dp[0])
print(*ans, sep='')


import io
import os
import sys
import math
from typing import NamedTuple
from collections import deque
fileno = sys.stdin.fileno()
input = io.BytesIO(os.read(fileno, os.fstat(fileno).st_size)).readline

class Edge(NamedTuple):
	to: int
	color: int
INF = 1000000
(N, M) = map(int, input().split())
A = [[] for i in range(N)]
for i in range(M):
	(x, y, c) = map(int, input().split())
	x -= 1
	y -= 1
	edge = Edge(to=x, color=c)
	A[y].append(edge)
color = [None for i in range(N)]
b = [INF for i in range(N)]
w = [INF for i in range(N)]
dp = [INF for i in range(N)]
b[N - 1] = w[N - 1] = dp[N - 1] = 0
q = deque([N - 1])
while q:
	vertex = q.popleft()
	if color[vertex] is not None:
		continue
	color[vertex] = int(b[vertex] < w[vertex])
	if dp[vertex] == INF:
		raise ValueError('Dist is too big %d ' % (vertex + 1))
	for edge in A[vertex]:
		if color[edge.to] is not None:
			continue
		if edge.color == 0:
			b[edge.to] = min(b[edge.to], dp[vertex] + 1)
		else:
			w[edge.to] = min(w[edge.to], dp[vertex] + 1)
		dp[edge.to] = max(b[edge.to], w[edge.to])
		if dp[edge.to] != INF:
			q.append(edge.to)
for i in range(N):
	if color[i] is None:
		color[i] = int(b[i] < w[i])
print(dp[0] if dp[0] != INF else -1)
print(''.join(map(str, color)))