```go
package main

import (
	"bufio"
	"os"
)

func writeInt(out *bufio.Writer, x int16) {
	if x == 0 {
		out.WriteByte('0')
		out.WriteByte('\n')
		return
	}
	var buf [10]byte
	pos := 9
	for x > 0 {
		buf[pos] = byte(x%10) + '0'
		x /= 10
		pos--
	}
	out.Write(buf[pos+1:])
	out.WriteByte('\n')
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}
	nStr := scanner.Bytes()
	n := 0
	for _, b := range nStr {
		n = n*10 + int(b-'0')
	}
	m := readInt()
	k := readInt()

	gridData := make([]bool, (n+2)*(m+2))
	grid := make([][]bool, n+2)
	for i := 0; i <= n+1; i++ {
		grid[i] = gridData[i*(m+2) : (i+1)*(m+2)]
	}

	for i := 1; i <= n; i++ {
		scanner.Scan()
		row := scanner.Bytes()
		for j := 1; j <= m; j++ {
			if row[j-1] == 'X' {
				grid[i][j] = true
			}
		}
	}

	cars := make([][2]int, k)
	for i := 0; i < k; i++ {
		r := readInt()
		c := readInt()
		cars[i] = [2]int{r, c}
		grid[r][c] = true
	}

	LData := make([]int16, (n+2)*(m+2))
	L := make([][]int16, n+2)
	for i := 0; i <= n+1; i++ {
		L[i] = LData[i*(m+2) : (i+1)*(m+2)]
	}

	RData := make([]int16, (n+2)*(m+2))
	R := make([][]int16, n+2)
	for i := 0; i <= n+1; i++ {
		R[i] = RData[i*(m+2) : (i+1)*(m+2)]
	}

	for i := 1; i <= n; i++ {
		curr := int16(0)
		for j := 1; j <= m; j++ {
			if grid[i][j] {
				curr = int16(j)
			}
			L[i][j] = curr
		}
		curr = int16(m + 1)
		for j := m; j >= 1; j-- {
			if grid[i][j] {
				curr = int16(j)
			}
			R[i][j] = curr
		}
	}

	dpData := make([]int16, (n+2)*(m+2))
	dp := make([][]int16, n+2)
	for i := 0; i <= n+1; i++ {
		dp[i] = dpData[i*(m+2) : (i+1)*(m+2)]
	}

	S := int16(0)
	for i := n; i >= 1; i-- {
		for j := m; j >= 1; j-- {
			if !grid[i][j] {
				minVal := dp[i+1][j]
				if dp[i][j+1] < minVal {
					minVal = dp[i][j+1]
				}
				if dp[i+1][j+1] < minVal {
					minVal = dp[i+1][j+1]
				}
				dp[i][j] = minVal + 1
				if dp[i][j] > S {
					S = dp[i][j]
				}
			}
		}
	}

	ans := make([]int16, k)
	var qL, qR [4005]int

	for q := k - 1; q >= 0; q-- {
		ans[q] = S

		r := cars[q][0]
		c := cars[q][1]

		grid[r][c] = false

		curr := int16(0)
		for j := 1; j <= m; j++ {
			if grid[r][j] {
				curr = int16(j)
			}
			L[r][j] = curr
		}
		curr = int16(m + 1)
		for j := m; j >= 1; j-- {
			if grid[r][j] {
				curr = int16(j)
			}
			R[r][j] = curr
		}

		for {
			LNew := int(S) + 1
			startRow := r - LNew + 1
			if startRow < 1 {
				startRow = 1
			}
			endRow := r + LNew - 1
			if endRow > n {
				endRow = n
			}

			if endRow-startRow+1 >= LNew {
				possible := false
				headL, tailL := 0, 0
				headR, tailR := 0, 0

				for w := startRow; w <= endRow; w++ {
					for headL < tailL && qL[headL] <= w-LNew {
						headL++
					}
					for headR < tailR && qR[headR] <= w-LNew {
						headR++
					}

					valL := L[w][c]
					for headL < tailL && L[qL[tailL-1]][c] <= valL {
						tailL--
					}
					qL[tailL] = w
					tailL++

					valR := R[w][c]
					for headR < tailR && R[qR[tailR-1]][c] >= valR {
						tailR--
					}
					qR[tailR] = w
					tailR++

					if w >= startRow+LNew-1 {
						maxL := L[qL[headL]][c]
						minR := R[qR[headR]][c]
						if int(minR-maxL-1) >= LNew {
							possible = true
							break
						}
					}
				}

				if possible {
					S = int16(LNew)
					continue
				}
			}
			break
		}
	}

	out := bufio.NewWriter(os.Stdout)
	for i := 0; i < k; i++ {
		writeInt(out, ans[i])
	}
	out.Flush()
}
```