```go
package main

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

type Pair struct {
	u int
	c int
}

type Edge struct {
	to  int
	rev int
	cap int
}

type Dinic struct {
	g     [][]Edge
	level []int
	it    []int
}

func NewDinic(n int) *Dinic {
	return &Dinic{
		g:     make([][]Edge, n),
		level: make([]int, n),
		it:    make([]int, n),
	}
}

func (d *Dinic) AddEdge(fr, to, cap int) {
	d.g[fr] = append(d.g[fr], Edge{to: to, rev: len(d.g[to]), cap: cap})
	d.g[to] = append(d.g[to], Edge{to: fr, rev: len(d.g[fr]) - 1, cap: 0})
}

func (d *Dinic) bfs(s, t int) bool {
	for i := range d.level {
		d.level[i] = -1
	}
	q := make([]int, len(d.g))
	head, tail := 0, 0
	d.level[s] = 0
	q[tail] = s
	tail++
	for head < tail {
		v := q[head]
		head++
		for _, e := range d.g[v] {
			if e.cap > 0 && d.level[e.to] < 0 {
				d.level[e.to] = d.level[v] + 1
				q[tail] = e.to
				tail++
			}
		}
	}
	return d.level[t] >= 0
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func (d *Dinic) dfs(v, t, f int) int {
	if v == t {
		return f
	}
	for ; d.it[v] < len(d.g[v]); d.it[v]++ {
		i := d.it[v]
		e := &d.g[v][i]
		if e.cap > 0 && d.level[e.to] == d.level[v]+1 {
			ret := d.dfs(e.to, t, min(f, e.cap))
			if ret > 0 {
				e.cap -= ret
				re := &d.g[e.to][e.rev]
				re.cap += ret
				return ret
			}
		}
	}
	return 0
}

func (d *Dinic) MaxFlow(s, t int) int {
	flow := 0
	const inf = int(1 << 30)
	for d.bfs(s, t) {
		for i := range d.it {
			d.it[i] = 0
		}
		for {
			f := d.dfs(s, t, inf)
			if f == 0 {
				break
			}
			flow += f
		}
	}
	return flow
}

func cntUpto(x, mod int) int {
	if x <= 0 {
		return 0
	}
	if mod == 0 {
		return x / 5
	}
	if x < mod {
		return 0
	}
	return (x-mod)/5 + 1
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') && data[idx] != '-' {
			idx++
		}
		sign := 1
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return sign * val
	}

	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()

	n := nextInt()
	b := nextInt()
	q := nextInt()

	pairs := make([]Pair, 0, q+2)
	pairs = append(pairs, Pair{0, 0})
	for i := 0; i < q; i++ {
		u := nextInt()
		c := nextInt()
		pairs = append(pairs, Pair{u, c})
	}
	pairs = append(pairs, Pair{b, n})

	sort.Slice(pairs, func(i, j int) bool {
		if pairs[i].u == pairs[j].u {
			return pairs[i].c < pairs[j].c
		}
		return pairs[i].u < pairs[j].u
	})

	uniq := make([]Pair, 0, len(pairs))
	for _, p := range pairs {
		if len(uniq) == 0 || uniq[len(uniq)-1].u != p.u {
			uniq = append(uniq, p)
		} else if uniq[len(uniq)-1].c != p.c {
			fmt.Fprint(w, "unfair")
			return
		}
	}

	for i := 0; i+1 < len(uniq); i++ {
		diffC := uniq[i+1].c - uniq[i].c
		diffU := uniq[i+1].u - uniq[i].u
		if diffC < 0 || diffC > diffU {
			fmt.Fprint(w, "unfair")
			return
		}
	}

	m := len(uniq) - 1
	source := 0
	resStart := 1
	intStart := 6
	sink := intStart + m
	dinic := NewDinic(sink + 1)

	quota := n / 5
	for r := 0; r < 5; r++ {
		dinic.AddEdge(source, resStart+r, quota)
	}

	for i := 0; i < m; i++ {
		node := intStart + i
		need := uniq[i+1].c - uniq[i].c
		dinic.AddEdge(node, sink, need)
		L := uniq[i].u
		R := uniq[i+1].u
		for r := 0; r < 5; r++ {
			cap := cntUpto(R, r) - cntUpto(L, r)
			if cap > 0 {
				dinic.AddEdge(resStart+r, node, cap)
			}
		}
	}

	if dinic.MaxFlow(source, sink) == n {
		fmt.Fprint(w, "fair")
	} else {
		fmt.Fprint(w, "unfair")
	}
}
```