package main

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

type pair struct {
	a, b int
}

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

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

	var q int
	fmt.Fscan(in, &q)

	synergy := make(map[pair]struct{}, q)
	for i := 0; i < q; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		synergy[pair{u, v}] = struct{}{}
	}

	frontier := []pair{{1, 1}}
	steps := 0

	for {
		
		for _, p := range frontier {
			if p.a == n && p.b == m {
				fmt.Fprintln(out, steps)
				return
			}
		}

		steps++
		nextMap := make(map[pair]struct{})
		for _, p := range frontier {
			bonus := 0
			if _, exists := synergy[p]; exists {
				bonus = 1
			}
			power := p.a + p.b + bonus

			
			na := power
			if na > n {
				na = n
			}
			nextMap[pair{na, p.b}] = struct{}{}

			
			nb := power
			if nb > m {
				nb = m
			}
			nextMap[pair{p.a, nb}] = struct{}{}
		}

		nextList := make([]pair, 0, len(nextMap))
		for p := range nextMap {
			nextList = append(nextList, p)
		}

		
		sort.Slice(nextList, func(i, j int) bool {
			if nextList[i].a != nextList[j].a {
				return nextList[i].a > nextList[j].a
			}
			return nextList[i].b > nextList[j].b
		})

		
		
		frontier = frontier[:0]
		maxB := -1
		for _, p := range nextList {
			if p.b > maxB {
				frontier = append(frontier, p)
				maxB = p.b
			}
		}
	}
}