#![allow(non_snake_case,unused_imports,dead_code)]
use std::io::Read;
use std::cmp::max;
use std::cmp::min;
use std::str::FromStr;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::BinaryHeap;
use std::cmp::Ordering;

fn comp_f64(a: &f64, b: &f64) -> Ordering {
    if a < b {
        return Ordering::Less;
    } else if a > b {
        return Ordering::Greater;
    }
    Ordering::Equal
}

fn main() {

    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut buf_it = buf.split_whitespace();

    let N = buf_it.next().unwrap().parse::<usize>().unwrap();
    let M = buf_it.next().unwrap().parse::<usize>().unwrap();
    let Q = buf_it.next().unwrap().parse::<usize>().unwrap();
    let S = (0..N).map(|_|
        buf_it.next().unwrap().chars().collect::<Vec<_>>()
    ).collect::<Vec<_>>();

    let XYXY = (0..Q).map(|_|
        (buf_it.next().unwrap().parse::<usize>().unwrap(),
        buf_it.next().unwrap().parse::<usize>().unwrap(),
        buf_it.next().unwrap().parse::<usize>().unwrap(),
        buf_it.next().unwrap().parse::<usize>().unwrap())
    ).collect::<Vec<_>>();

    let mut Done = (0..N+2).map(|_|
        (0..M+2).map(|_| false).collect::<Vec<_>>())
        .collect::<Vec<_>>();
    let mut Rmap = (0..N+2).map(|_|
        (0..M+2).map(|_| 0).collect::<Vec<_>>())
        .collect::<Vec<_>>();
    let mut Elmap = (0..N+2).map(|_|
        (0..M+2).map(|_| 0).collect::<Vec<_>>())
        .collect::<Vec<_>>();
    let mut Ermap = (0..N+2).map(|_|
        (0..M+2).map(|_| 0).collect::<Vec<_>>())
        .collect::<Vec<_>>();
    let mut Eumap = (0..N+2).map(|_|
        (0..M+2).map(|_| 0).collect::<Vec<_>>())
        .collect::<Vec<_>>();
    let mut Edmap = (0..N+2).map(|_|
        (0..M+2).map(|_| 0).collect::<Vec<_>>())
        .collect::<Vec<_>>();

    for i in 1..N+1{
        for j in 1..M+1{
            if Done[i][j] {continue;}
            if S[i-1][j-1] == '0' {continue;}
            Rmap[i][j] = 1;
            Done[i][j] = true;
            let mut q = vec![(i,j)]; 
            while q.len()>0{
                let (i,j) = q.pop().unwrap();
                for (di,dj) in vec![(1,0),(!0,0),(0,1),(0,!0)]{
                    let i = i.wrapping_add(di);
                    let j = j.wrapping_add(dj);
                    if i==0 || i>=N+1 || j==0 || j>=M+1{ continue}
                    if S[i-1][j-1] == '0' { continue}
                    if Done[i][j] { continue}
                    Done[i][j] = true;
                    if di==1{
                        Eumap[i][j] = 1;
                    } else if di==!0 {
                        Edmap[i][j] = 1;
                    } else if dj==1{
                        Elmap[i][j] = 1;
                    } else if dj==!0{
                        Ermap[i][j] = 1;
                    }
                    q.push((i,j));
                }
            }
        }
    }

    for i in 1..N+1{
        for j in 1..M+2{
            Elmap[i+1][j] += Elmap[i][j];
            Ermap[i+1][j] += Ermap[i][j];
            Rmap[i+1][j] += Rmap[i][j];
        }
    }
    for i in 1..N+2{
        for j in 1..M+1{
            Eumap[i][j+1] += Eumap[i][j];
            Edmap[i][j+1] += Edmap[i][j];
            Rmap[i][j+1] += Rmap[i][j];
        }
    }

    for &(x1,y1,x2,y2) in &XYXY{
        let mut ans = 0;

        ans += Elmap[x2][y1] - Elmap[x1-1][y1];
        ans += Ermap[x2][y2] - Ermap[x1-1][y2];
        ans += Eumap[x1][y2] - Eumap[x1][y1-1];
        ans += Edmap[x2][y2] - Edmap[x2][y1-1];
        ans += Rmap[x2][y2] + Rmap[x1-1][y1-1] - Rmap[x2][y1-1] - Rmap[x1-1][y2];

        println!("{}",ans);
    }
}

Measured memory_bytes: 124664