```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type T struct {
	x, y int64
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, m int
	fmt.Fscan(in, &n, &m)
	_ = n
	var sx, sy, fx, fy int64
	fmt.Fscan(in, &sx, &sy, &fx, &fy)
	teles := make([]T, m)
	xset := make(map[int64]struct{})
	yset := make(map[int64]struct{})
	for i := 0; i < m; i++ {
		var x, y int64
		fmt.Fscan(in, &x, &y)
		teles[i] = T{x, y}
		xset[x] = struct{}{}
		yset[y] = struct{}{}
	}
	vecx := make([]int64, 0, len(xset))
	for x := range xset {
		vecx = append(vecx, x)
	}
	sort.Slice(vecx, func(i, j int) bool { return vecx[i] < vecx[j] })
	vecy := make([]int64, 0, len(yset))
	for y := range yset {
		vecy = append(vecy, y)
	}
	sort.Slice(vecy, func(i, j int) bool { return vecy[i] < vecy[j] })
	lx := len(vecx)
	ly := len(vecy)
	idx := make(map[int64]int)
	for i, v := range vecx {
		idx[v] = i
	}
	idy := make(map[int64]int)
	for i, v := range vecy {
		idy[v] = i
	}
	total := lx + ly
	parent := make([]int, total)
	rank := make([]int, total)
	for i := 0; i < total; i++ {
		parent[i] = i
		rank[i] = 1
	}
	var find func(int) int
	find = func(u int) int {
		if parent[u] != u {
			parent[u] = find(parent[u])
		}
		return parent[u]
	}
	union := func(u, v int) {
		pu := find(u)
		pv := find(v)
		if pu == pv {
			return
		}
		if rank[pu] < rank[pv] {
			parent[pu] = pv
		} else if rank[pv] < rank[pu] {
			parent[pv] = pu
		} else {
			parent[pv] = pu
			rank[pu]++
		}
	}
	for _, t := range teles {
		l := idx[t.x]
		r := lx + idy[t.y]
		union(l, r)
	}
	comp_map := make(map[int]int)
	cid := 0
	for i := 0; i < total; i++ {
		p := find(i)
		if _, ok := comp_map[p]; !ok {
			comp_map[p] = cid
			cid++
		}
	}
	num_comp := cid
	comp_tel := make([][]T, num_comp)
	for _, t := range teles {
		l := idx[t.x]
		p := find(l)
		c := comp_map[p]
		comp_tel[c] = append(comp_tel[c], t)
	}
	min_enter := make([]int64, num_comp)
	min_exit := make([]int64, num_comp)
	for i := 0; i < num_comp; i++ {
		min_enter[i] = 1 << 60
		min_exit[i] = 1 << 60
	}
	for i := 0; i < num_comp; i++ {
		for _, t := range comp_tel[i] {
			ent := abs(sx - t.x)
			ent2 := abs(sy - t.y)
			if ent2 < ent {
				ent = ent2
			}
			if ent < min_enter[i] {
				min_enter[i] = ent
			}
			ex := abs(t.x - fx) + abs(t.y - fy)
			if ex < min_exit[i] {
				min_exit[i] = ex
			}
		}
	}
	ans := abs(sx - fx) + abs(sy - fy)
	for i := 0; i < num_comp; i++ {
		if min_enter[i] + min_exit[i] < ans {
			ans = min_enter[i] + min_exit[i]
		}
	}
	fmt.Println(ans)
}

func abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}
```