```go
package main

import (
	"bufio"
	"io"
	"math/bits"
	"os"
	"strconv"
)

var data []byte
var ptr int
var n, m int
var pref [][]int64
var totalOnes int64
var cellCount int64

func nextInt() int64 {
	for ptr < len(data) && (data[ptr] < '0' || data[ptr] > '9') {
		ptr++
	}
	var v int64
	for ptr < len(data) && data[ptr] >= '0' && data[ptr] <= '9' {
		v = v*10 + int64(data[ptr]-'0')
		ptr++
	}
	return v
}

func nextBytes() []byte {
	for ptr < len(data) && data[ptr] <= ' ' {
		ptr++
	}
	start := ptr
	for ptr < len(data) && data[ptr] > ' ' {
		ptr++
	}
	return data[start:ptr]
}

func count1(k int64) int64 {
	if k == 0 {
		return 0
	}
	p := int64(1) << (bits.Len64(uint64(k)) - 1)
	if k == p {
		return p / 2
	}
	l := k - p
	return p/2 + l - count1(l)
}

func prefixSum(x, y int64) int64 {
	if x <= 0 || y <= 0 {
		return 0
	}

	br := x / int64(n)
	bc := y / int64(m)
	rx := int(x % int64(n))
	cy := int(y % int64(m))

	c1r := count1(br)
	c0r := br - c1r
	c1c := count1(bc)
	c0c := bc - c1c

	same := c0r*c0c + c1r*c1c
	sum := totalOnes*same + (cellCount-totalOnes)*(br*bc-same)

	pr := bits.OnesCount64(uint64(br)) & 1
	pc := bits.OnesCount64(uint64(bc)) & 1

	if rx > 0 && bc > 0 {
		base := pref[rx][m]
		area := int64(rx) * int64(m)
		var sameC int64
		if pr == 0 {
			sameC = c0c
		} else {
			sameC = c1c
		}
		sum += base*sameC + (area-base)*(bc-sameC)
	}

	if cy > 0 && br > 0 {
		base := pref[n][cy]
		area := int64(n) * int64(cy)
		var sameR int64
		if pc == 0 {
			sameR = c0r
		} else {
			sameR = c1r
		}
		sum += base*sameR + (area-base)*(br-sameR)
	}

	if rx > 0 && cy > 0 {
		base := pref[rx][cy]
		area := int64(rx) * int64(cy)
		if pr^pc == 0 {
			sum += base
		} else {
			sum += area - base
		}
	}

	return sum
}

func main() {
	data, _ = io.ReadAll(os.Stdin)

	n = int(nextInt())
	m = int(nextInt())
	q := int(nextInt())

	pref = make([][]int64, n+1)
	for i := range pref {
		pref[i] = make([]int64, m+1)
	}

	for i := 1; i <= n; i++ {
		row := nextBytes()
		for j := 1; j <= m; j++ {
			v := int64(row[j-1] - '0')
			pref[i][j] = pref[i-1][j] + pref[i][j-1] - pref[i-1][j-1] + v
		}
	}

	totalOnes = pref[n][m]
	cellCount = int64(n) * int64(m)

	out := make([]byte, 0, q*20)
	for ; q > 0; q-- {
		x1 := nextInt()
		y1 := nextInt()
		x2 := nextInt()
		y2 := nextInt()
		ans := prefixSum(x2, y2) - prefixSum(x1-1, y2) - prefixSum(x2, y1-1) + prefixSum(x1-1, y1-1)
		out = strconv.AppendInt(out, ans, 10)
		out = append(out, '\n')
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out)
	w.Flush()
}
```