package main

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

type Edge struct {
	to int
	l  int
	r  int
}

type Item struct {
	node int
	val  int
}

type PQ []Item

func (pq PQ) Len() int            { return len(pq) }
func (pq PQ) Less(i, j int) bool  { return pq[i].val > pq[j].val }
func (pq PQ) Swap(i, j int)       { pq[i], pq[j] = pq[j], pq[i] }
func (pq *PQ) Push(x interface{}) { *pq = append(*pq, x.(Item)) }
func (pq *PQ) Pop() interface{} {
	old := *pq
	n := len(old)
	it := old[n-1]
	*pq = old[:n-1]
	return it
}

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

	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}
	adj := make([][]Edge, n)
	lset := make(map[int]struct{})
	for i := 0; i < m; i++ {
		var a, b, l, r int
		fmt.Fscan(in, &a, &b, &l, &r)
		a--
		b--
		adj[a] = append(adj[a], Edge{to: b, l: l, r: r})
		adj[b] = append(adj[b], Edge{to: a, l: l, r: r})
		lset[l] = struct{}{}
	}
	if n == 0 {
		fmt.Fprintln(out, "Nice work, Dima!")
		return
	}
	lvals := make([]int, 0, len(lset))
	for v := range lset {
		lvals = append(lvals, v)
	}
	sort.Ints(lvals)

	best := 0
	const INF = int(1 << 30)

	for _, L := range lvals {
		val := make([]int, n)
		for i := 0; i < n; i++ {
			val[i] = -1
		}
		pq := &PQ{}
		heap.Init(pq)
		val[0] = INF
		heap.Push(pq, Item{node: 0, val: INF})

		for pq.Len() > 0 {
			it := heap.Pop(pq).(Item)
			u := it.node
			if it.val != val[u] {
				continue
			}
			if u == n-1 {
				break
			}
			for _, e := range adj[u] {
				if e.l > L {
					continue
				}
				nv := it.val
				if e.r < nv {
					nv = e.r
				}
				if nv > val[e.to] {
					val[e.to] = nv
					heap.Push(pq, Item{node: e.to, val: nv})
				}
			}
		}
		rmax := val[n-1]
		if rmax >= L {
			cand := rmax - L + 1
			if cand > best {
				best = cand
			}
		}
	}

	if best <= 0 {
		fmt.Fprintln(out, "Nice work, Dima!")
	} else {
		fmt.Fprintln(out, best)
	}
}