package main

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

type Node struct {
	sum  int32
	pref int32
	suff int32
	len  int32
}

type LineInfo struct {
	lineID int32
	pos    int32
}

func build(tree []Node, node int, l, r int) {
	tree[node].len = int32(r - l + 1)
	tree[node].pref = tree[node].len
	tree[node].suff = tree[node].len
	tree[node].sum = tree[node].len * (tree[node].len + 1) / 2
	if l == r {
		return
	}
	mid := (l + r) / 2
	build(tree, 2*node, l, mid)
	build(tree, 2*node+1, mid+1, r)
}

func update(tree []Node, node int, l, r int, idx int, val int) {
	if l == r {
		if val == 1 {
			tree[node].pref = 1
			tree[node].suff = 1
			tree[node].sum = 1
		} else {
			tree[node].pref = 0
			tree[node].suff = 0
			tree[node].sum = 0
		}
		return
	}
	mid := (l + r) / 2
	if idx <= mid {
		update(tree, 2*node, l, mid, idx, val)
	} else {
		update(tree, 2*node+1, mid+1, r, idx, val)
	}
	lc := 2 * node
	rc := 2*node + 1
	tree[node].pref = tree[lc].pref
	if tree[lc].pref == tree[lc].len {
		tree[node].pref += tree[rc].pref
	}
	tree[node].suff = tree[rc].suff
	if tree[rc].suff == tree[rc].len {
		tree[node].suff += tree[lc].suff
	}
	tree[node].sum = tree[lc].sum + tree[rc].sum + tree[lc].suff*tree[rc].pref
}

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

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

	cellLines := make([][][2]LineInfo, n+1)
	cellLineCount := make([][]int8, n+1)
	state := make([][]int8, n+1)
	for i := 1; i <= n; i++ {
		cellLines[i] = make([][2]LineInfo, m+1)
		cellLineCount[i] = make([]int8, m+1)
		state[i] = make([]int8, m+1)
		for j := 1; j <= m; j++ {
			state[i][j] = 1
		}
	}

	lineLen := make([]int, n+m)
	lineID := 0

	for c := 1; c <= m; c++ {
		r := 1
		currC := c
		dir := 1
		idx := 0
		for r <= n && currC <= m {
			count := cellLineCount[r][currC]
			cellLines[r][currC][count] = LineInfo{int32(lineID), int32(idx)}
			cellLineCount[r][currC]++
			if dir == 1 {
				currC++
				dir = 2
			} else {
				r++
				dir = 1
			}
			idx++
		}
		lineLen[lineID] = idx
		lineID++
	}

	for r := 1; r <= n; r++ {
		currR := r
		c := 1
		dir := 2
		idx := 0
		for currR <= n && c <= m {
			count := cellLineCount[currR][c]
			cellLines[currR][c][count] = LineInfo{int32(lineID), int32(idx)}
			cellLineCount[currR][c]++
			if dir == 1 {
				c++
				dir = 2
			} else {
				currR++
				dir = 1
			}
			idx++
		}
		lineLen[lineID] = idx
		lineID++
	}

	totalNodes := 0
	for i := 0; i < n+m; i++ {
		totalNodes += 4 * lineLen[i]
	}
	treeData := make([]Node, totalNodes)
	trees := make([][]Node, n+m)
	offset := 0
	for i := 0; i < n+m; i++ {
		trees[i] = treeData[offset : offset+4*lineLen[i]]
		offset += 4 * lineLen[i]
	}

	var totalSum int64 = 0
	freeCells := int64(n * m)

	for i := 0; i < n+m; i++ {
		if lineLen[i] > 0 {
			build(trees[i], 1, 0, lineLen[i]-1)
			totalSum += int64(trees[i][1].sum)
		}
	}

	for i := 0; i < q; i++ {
		var x, y int
		fmt.Fscan(in, &x, &y)

		state[x][y] ^= 1
		val := int(state[x][y])
		if val == 1 {
			freeCells++
		} else {
			freeCells--
		}

		for k := 0; k < 2; k++ {
			lID := int(cellLines[x][y][k].lineID)
			pos := int(cellLines[x][y][k].pos)

			totalSum -= int64(trees[lID][1].sum)
			update(trees[lID], 1, 0, lineLen[lID]-1, pos, val)
			totalSum += int64(trees[lID][1].sum)
		}

		fmt.Fprintln(out, totalSum-freeCells)
	}
}