package main

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

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	sign := 1
	if fs.idx < fs.n && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val * sign
}

type Pair struct {
	a int
	b int
}

func key(a, b int) uint64 {
	return (uint64(uint32(a)) << 32) | uint64(uint32(b))
}

func main() {
	in := NewFastScanner()
	n := in.NextInt()
	m := in.NextInt()
	q := in.NextInt()

	special := make(map[uint64]struct{}, q)
	for i := 0; i < q; i++ {
		a := in.NextInt()
		b := in.NextInt()
		special[key(a, b)] = struct{}{}
	}

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

	for {
		for _, p := range frontier {
			if p.a == n && p.b == m {
				out := bufio.NewWriterSize(os.Stdout, 1<<20)
				fmt.Fprintln(out, steps)
				out.Flush()
				return
			}
		}

		cands := make([]Pair, 0, len(frontier)*2)
		for _, p := range frontier {
			power := p.a + p.b
			if _, ok := special[key(p.a, p.b)]; ok {
				power++
			}
			if p.a < n {
				na := power
				if na > n {
					na = n
				}
				if na > p.a {
					cands = append(cands, Pair{na, p.b})
				}
			}
			if p.b < m {
				nb := power
				if nb > m {
					nb = m
				}
				if nb > p.b {
					cands = append(cands, Pair{p.a, nb})
				}
			}
		}

		steps++

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

		dedup := cands[:0]
		lastA := -1
		for _, p := range cands {
			if p.a != lastA {
				dedup = append(dedup, p)
				lastA = p.a
			}
		}

		next := make([]Pair, 0, len(dedup))
		bestB := 0
		for i := len(dedup) - 1; i >= 0; i-- {
			if dedup[i].b > bestB {
				next = append(next, dedup[i])
				bestB = dedup[i].b
			}
		}
		for l, r := 0, len(next)-1; l < r; l, r = l+1, r-1 {
			next[l], next[r] = next[r], next[l]
		}

		frontier = next
	}
}