```go
package main

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

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	if a < 0 {
		return -a
	}
	return a
}

func exgcd(a, b int64) (int64, int64, int64) {
	if b == 0 {
		return a, 1, 0
	}
	d, x1, y1 := exgcd(b, a%b)
	x := y1
	y := x1 - (a/b)*y1
	return d, x, y
}

func modInv(a, mod int64) int64 {
	_, x, _ := exgcd(a, mod)
	x %= mod
	if x < 0 {
		x += mod
	}
	return x
}

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

	var n, m int64
	var k int
	if _, err := fmt.Fscan(in, &n, &m, &k); err != nil {
		return
	}

	M1 := 2 * n
	M2 := 2 * m
	g := gcd(M1, M2)
	mod2 := M2 / g
	l := M1 * mod2
	gnm := gcd(n, m)
	Lcorner := (n / gnm) * m

	inv := modInv(M1/g, mod2)

	for i := 0; i < k; i++ {
		var x, y int64
		fmt.Fscan(in, &x, &y)
		ax := [2]int64{x, M1 - x}
		by := [2]int64{y, M2 - y}
		best := int64(-1)
		for _, a := range ax {
			for _, b := range by {
				dd := b - a
				if dd%g != 0 {
					continue
				}
				ddg := dd / g
				kmod := ddg % mod2
				if kmod < 0 {
					kmod += mod2
				}
				s := (kmod * (inv % mod2)) % mod2
				T := a + M1*s
				if T >= l {
					T %= l
				}
				if T >= 0 && T < Lcorner {
					if best == -1 || T < best {
						best = T
					}
				}
			}
		}
		fmt.Fprintln(out, best)
	}
}
```