#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <cassert>
using namespace std;

#define int long long
const int MAX_ROW = 300010;
int TotRow, TotCol;

struct IdRange
{
	int BeginId, LastId;

	IdRange(int beginId, int lastId) :BeginId(beginId), LastId(lastId) {}

	IdRange() {}
};

template<class ValType>

struct SplayTree
{
private:
	struct Node
	{
		ValType Val;
		Node *LeftSon, *RightSon, *Father;
		int Cnt, Size;

		Node(ValType val, int cnt, Node *father) :Val(val), Father(father), Cnt(cnt), Size(cnt), LeftSon(NULL), RightSon(NULL) {}

		bool IsRoot()
		{
			return Father == NULL || (Father->LeftSon != this && Father->RightSon != this);
		}

		bool IsLeftSon()
		{
			assert(!IsRoot());
			return Father->LeftSon == this;
		}

		void Refresh()
		{
			Size = (LeftSon ? LeftSon->Size : 0) + (RightSon ? RightSon->Size : 0) + Cnt;
		}
	};
	Node *Root;

	void SetRoot(Node *cur)
	{
		Root = cur;
		if (Root)
			Root->Father = NULL;
	}

	void Rotate(Node *cur)
	{
		Node *gfa = cur->Father->Father;
		Node **gfaSon = cur->Father->IsRoot() ? &Root : cur->Father->IsLeftSon() ? &gfa->LeftSon : &gfa->RightSon;
		Node **faSon = cur->IsLeftSon() ? &cur->Father->LeftSon : &cur->Father->RightSon;
		Node **curSon = cur->IsLeftSon() ? &cur->RightSon : &cur->LeftSon;
		*faSon = *curSon;
		if (*faSon)
			(*faSon)->Father = cur->Father;
		*curSon = cur->Father;
		(*curSon)->Father = cur;
		*gfaSon = cur;
		(*gfaSon)->Father = gfa;
		(*curSon)->Refresh();
		cur->Refresh();
	}

	void Splay(Node *cur)
	{
		while (!cur->IsRoot())
		{
			if (!cur->Father->IsRoot())
				Rotate(cur->IsLeftSon() == cur->Father->IsLeftSon() ? cur->Father : cur);
			Rotate(cur);
		}
	}

	pair<Node*, int> FindKth(Node *cur, int rank)//pair中int指rank对应数据有并列时，rank与并列最高排名的距离[1...cutCnt]
	{
		while (true)
		{
			assert(cur);
			int leftSize = cur->LeftSon ? cur->LeftSon->Size : 0, rootSize;
			if (rank <= leftSize)
				cur = cur->LeftSon;
			else if (rank <= (rootSize = leftSize + cur->Cnt))
				return pair<Node*, int>(cur, rank - leftSize);
			else
			{
				cur = cur->RightSon;
				rank -= rootSize;
			}
		}
	}

	void InsertBack(Node *&root, ValType val, int cnt)
	{
		Node **cur = &root, *prev = root ? root->Father : NULL;
		while (*cur)
		{
			prev = *cur;
			cur = &(*cur)->RightSon;
		}
		*cur = new Node(val, cnt, prev);
		Splay(*cur);
	}

	Node *GetPrevNode(Node *cur)
	{
		cur = cur->LeftSon;
		if (!cur)
			return NULL;
		while (cur->RightSon)
			cur = cur->RightSon;
		return cur;
	}

	Node *GetNextNode(Node *cur)
	{
		cur = cur->RightSon;
		if (!cur)
			return NULL;
		while (cur->LeftSon)
			cur = cur->LeftSon;
		return cur;
	}

	void DeleteNode(Node *cur)
	{
		Splay(cur);
		if (!cur->LeftSon || !cur->RightSon)
			SetRoot(cur->LeftSon ? cur->LeftSon : cur->RightSon);
		else if (cur->LeftSon && cur->RightSon)
		{
			Node *NewRoot = GetPrevNode(cur);
			Splay(NewRoot);
			assert(NewRoot->RightSon == cur && cur->LeftSon == NULL);
			NewRoot->RightSon = cur->RightSon;
			if (NewRoot->RightSon)
				NewRoot->RightSon->Father = NewRoot;
		}
	}

public:

	void InsertBack(ValType val, int cnt)
	{
		InsertBack(Root, val, cnt);
	}

	pair<ValType, int> FindKth(int rank)//pair中int指rank对应数据有并列时，rank与并列最高排名的距离[1...cutCnt]
	{
		pair<Node*, int> state = FindKth(Root, rank);
		Node *find = state.first;
		Splay(find);
		return pair<ValType, int>(find->Val, state.second);
	}

	void Split(int rank, int cutCnt, ValType*(*SplitVal)(ValType&, int), bool(*IsNull)(ValType&))//把并列的分为[1...curCnt-1]和[cutCnt+1...cnt]两部分
	{
		pair<Node*, int> state = FindKth(Root, rank);
		Node *cur = state.first;
		ValType* a = SplitVal(cur->Val, cutCnt);
		if (IsNull(a[0]) && !IsNull(a[1]))
		{
			swap(a[0], a[1]);
			cutCnt = cur->Cnt - cutCnt + 1;
		}
		if (IsNull(a[0]))
			DeleteNode(cur);
		else
		{
			Node *newNode = NULL;
			if (!IsNull(a[1]))
			{
				Node *nextFa = GetNextNode(cur);
				if (nextFa == NULL)
				{
					newNode = new Node(a[1], cur->Cnt - cutCnt, cur);
					cur->RightSon = newNode;
				}
				else
				{
					newNode = new Node(a[1], cur->Cnt - cutCnt, nextFa);
					nextFa->LeftSon = newNode;
				}
			}
			cur->Val = a[0];
			cur->Cnt = cutCnt - 1;
			Splay(newNode ? newNode : cur);
		}
	}
};
SplayTree<IdRange> _trees[MAX_ROW];

void Init()
{
	for (int row = 1; row <= TotRow; row++)
		_trees[row].InsertBack(IdRange((row - 1) * TotCol + 1, row * TotCol - 1), TotCol - 1);
	for (int row = 1; row <= TotRow; row++)
		_trees[0].InsertBack(IdRange(row * TotCol, row * TotCol), 1);
}

IdRange* SplitRange(IdRange& range, int cutLen)
{
	IdRange* a = new IdRange[2];
	a[0] = IdRange(range.BeginId, range.BeginId + cutLen - 2);
	a[1] = IdRange(range.BeginId + cutLen, range.LastId);
	return a;
}

bool IsNull(IdRange& range)
{
	return range.BeginId > range.LastId;
}

int Solve(int row, int col)
{
	if (col == TotCol)
	{
		//出队
		pair<IdRange, int> out = _trees[0].FindKth(row);
		//向前看齐
		_trees[0].Split(row, 1, SplitRange, IsNull);
		//入队
		_trees[0].InsertBack(out.first, 1);
		return out.first.BeginId;
	}
	else
	{

		//出队
		pair<IdRange, int> out = _trees[row].FindKth(col);
		//向左看齐
		_trees[row].Split(col, out.second, SplitRange, IsNull);
		pair<IdRange, int> rowBack = _trees[0].FindKth(row);
		_trees[row].InsertBack(rowBack.first, 1);
		//向前看齐
		_trees[0].Split(row, 1, SplitRange, IsNull);
		//入队
		_trees[0].InsertBack(IdRange(out.first.BeginId + out.second - 1, out.first.BeginId + out.second - 1), 1);
		return out.first.BeginId + out.second - 1;
	}
}

#undef int
int main()
{
	int opCnt;
	scanf("%lld%lld%d", &TotRow, &TotCol, &opCnt);
	Init();
	while (opCnt--)
	{
		long long row, col;
		scanf("%lld%lld", &row, &col);
		printf("%lld\n", Solve(row, col));
	}
	return 0;
}