package main

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

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

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	scanner.Scan()
	m, _ := strconv.Atoi(scanner.Text())
	scanner.Scan()
	k, _ := strconv.Atoi(scanner.Text())

	grid := make([]byte, n*m)
	for i := 0; i < n; i++ {
		scanner.Scan()
		copy(grid[i*m:(i+1)*m], scanner.Bytes())
	}

	cars := make([]int, k*2)
	for i := 0; i < k; i++ {
		scanner.Scan()
		r, _ := strconv.Atoi(scanner.Text())
		scanner.Scan()
		c, _ := strconv.Atoi(scanner.Text())
		cars[i*2] = r - 1
		cars[i*2+1] = c - 1
		grid[(r-1)*m+(c-1)] = 'X'
	}

	dp := make([]int16, n*m)
	var S int = 0
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			if grid[i*m+j] == '.' {
				if i == 0 || j == 0 {
					dp[i*m+j] = 1
				} else {
					min := dp[(i-1)*m+j]
					if dp[i*m+j-1] < min {
						min = dp[i*m+j-1]
					}
					if dp[(i-1)*m+j-1] < min {
						min = dp[(i-1)*m+j-1]
					}
					dp[i*m+j] = min + 1
				}
				if int(dp[i*m+j]) > S {
					S = int(dp[i*m+j])
				}
			}
		}
	}
	dp = nil

	left := make([]int16, n*m)
	right := make([]int16, n*m)

	updateRow := func(r int) {
		l := int16(-1)
		for j := 0; j < m; j++ {
			if grid[r*m+j] == 'X' {
				left[r*m+j] = 10000
				l = -1
			} else {
				if l == -1 {
					l = int16(j)
				}
				left[r*m+j] = l
			}
		}
		rg := int16(-1)
		for j := m - 1; j >= 0; j-- {
			if grid[r*m+j] == 'X' {
				right[r*m+j] = -10000
				rg = -1
			} else {
				if rg == -1 {
					rg = int16(j)
				}
				right[r*m+j] = rg
			}
		}
	}

	for i := 0; i < n; i++ {
		updateRow(i)
	}

	var qL_idx, qL_val [4005]int16
	var qR_idx, qR_val [4005]int16

	check := func(r, c, W int) bool {
		if W > n || W > m {
			return false
		}
		startRow := r - W + 1
		if startRow < 0 {
			startRow = 0
		}
		endRow := r + W - 1
		if endRow >= n {
			endRow = n - 1
		}
		if endRow-startRow+1 < W {
			return false
		}

		headL, tailL := 0, 0
		headR, tailR := 0, 0

		for i := startRow; i <= endRow; i++ {
			vL := left[i*m+c]
			for tailL > headL && qL_val[tailL-1] <= vL {
				tailL--
			}
			qL_idx[tailL] = int16(i)
			qL_val[tailL] = vL
			tailL++

			vR := right[i*m+c]
			for tailR > headR && qR_val[tailR-1] >= vR {
				tailR--
			}
			qR_idx[tailR] = int16(i)
			qR_val[tailR] = vR
			tailR++

			if int(qL_idx[headL]) <= i-W {
				headL++
			}
			if int(qR_idx[headR]) <= i-W {
				headR++
			}

			if i-startRow+1 >= W {
				if int(qL_val[headL]) <= int(qR_val[headR])-W+1 {
					return true
				}
			}
		}
		return false
	}

	ans := make([]int, k)
	for i := k - 1; i >= 0; i-- {
		ans[i] = S
		r, c := cars[i*2], cars[i*2+1]
		grid[r*m+c] = '.'
		updateRow(r)
		for check(r, c, S+1) {
			S++
		}
	}

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