```go
package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"sort"
)

const INF int64 = 2e18

type Edge struct {
	to     int
	weight int64
}

type Item struct {
	node int
	dist int64
}

type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool { return pq[i].dist < pq[j].dist }

func (pq PriorityQueue) Swap(i, j int) { pq[i], pq[j] = pq[j], pq[i] }

func (pq *PriorityQueue) Push(x interface{}) {
	item := x.(*Item)
	*pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	*pq = old[0 : n-1]
	return item
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, m int
	fmt.Fscan(reader, &n, &m)

	adj := make([][]Edge, n+1)
	for i := 0; i < m; i++ {
		var u, v int
		var y int64
		fmt.Fscan(reader, &u, &v, &y)
		adj[u] = append(adj[u], Edge{to: v, weight: y})
		adj[v] = append(adj[v], Edge{to: u, weight: y})
	}

	dist := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		dist[i] = INF
	}

	pq := &PriorityQueue{}
	heap.Init(pq)

	dist[1] = 0
	heap.Push(pq, &Item{node: 1, dist: 0})

	for pq.Len() > 0 {
		item := heap.Pop(pq).(*Item)
		u := item.node
		d := item.dist

		if d > dist[u] {
			continue
		}

		for _, e := range adj[u] {
			if dist[u]+e.weight < dist[e.to] {
				dist[e.to] = dist[u] + e.weight
				heap.Push(pq, &Item{node: e.to, dist: dist[e.to]})
			}
		}
	}

	if dist[n] == INF {
		fmt.Fprintln(writer, "inf")
		return
	}

	distSet := make(map[int64]bool)
	for i := 1; i <= n; i++ {
		if dist[i] <= dist[n] {
			distSet[dist[i]] = true
		}
	}

	sortedDists := make([]int64, 0, len(distSet))
	for d := range distSet {
		sortedDists = append(sortedDists, d)
	}
	sort.Slice(sortedDists, func(i, j int) bool { return sortedDists[i] < sortedDists[j] })

	type Game struct {
		mask string
		time int64
	}
	var games []Game

	for i := 0; i < len(sortedDists)-1; i++ {
		d1 := sortedDists[i]
		d2 := sortedDists[i+1]
		if d2 > d1 {
			time := d2 - d1
			maskBytes := make([]byte, n)
			for j := 1; j <= n; j++ {
				if dist[j] <= d1 {
					maskBytes[j-1] = '1'
				} else {
					maskBytes[j-1] = '0'
				}
			}
			games = append(games, Game{string(maskBytes), time})
		}
	}

	fmt.Fprintln(writer, dist[n], len(games))
	for _, g := range games {
		fmt.Fprintln(writer, g.mask, g.time)
	}
}
```