#include <bits/stdc++.h>

using namespace std;

const int MAXR = , MAXC = , MAXN =  * MAXR + ;

int R, C, Q;

int am0[MAXC][MAXR];

char grid[MAXR][MAXC];

bool mark[MAXN];

int am[MAXN][MAXC];

int change[MAXN][MAXC];

inline void split(int at, int l, int r)

{

    mark[at] = false;

    for (int i = ; i <= C; ++i)

        if (change[at][i] < )

        {

            int got = am0[i][r] - am0[i][l];

            if (change[at][i] == )

            got = r - l - got;

            am[at][i] = got;

        }

    if (l +  != r)

    {

        mark[at *  + ] = true;

        mark[at *  + ] = true;

        for (int i = ; i <= C; ++i)

            if (change[at][i] < )

            {

                change[at *  + ][i] = change[at][i];

                change[at *  + ][i] = change[at][i];

                change[at][i] = ;

            }

    }

}

void update(int at, int l, int r, int nl, int nr, int cols[])

{

    if (mark[at])

        split(at, l, r);

    if (l == nl && r == nr)

    {

        mark[at] = true;

        for (int i = ; i <= C; ++i)

            if (cols[i] < )

                change[at][i] = cols[i];

        split(at, l, r);

        return;

    }

    int m = (l + r) / ;

    if (nr <= m)

        update(at *  + , l, m, nl, nr, cols);

    else if (m <= nl)

        update(at *  + , m, r, nl, nr, cols);

    else

    {

        update(at *  + , l, m, nl, m, cols);

        update(at *  + , m, r, m, nr, cols);

    }

    if (mark[at *  + ])

        split(at *  + , l, m);

    if (mark[at *  + ])

        split(at *  + , m, r);

    for (int i = ; i <= C; ++i) // join

        am[at][i] = am[at *  + ][i] + am[at *  + ][i];

}

void read()

{

    scanf("%d %d %d", &R, &C, &Q);

    for (int i = ; i < R; ++i)

        scanf("%s", grid[i]);

}

void solve()

{

    for (int i = ; i <= C; ++i)

        for (int j = ; j <= R; ++j)

        {

            am0[i][j] = am0[i][j - ];

            if (grid[j - ][i - ] == '')

                ++am0[i][j];

        }

    int cols[MAXC];

    for (int i = ; i < MAXC; ++i)

        cols[i] = ;

    update(, , R, , R, cols);

    int r1, r2, c1, c2, x;

    if (mark[])

        split(, , R);

    for (int i = ; i < Q; ++i)

    {

        scanf("%d %d %d %d %d", &r1, &r2, &c1, &c2, &x);

        for (int j = ; j <= C; ++j)

            if (j >= c1 && j <= c2)

                cols[j] = x;

            else

                cols[j] = ;

        update(, , R, r1 - , r2, cols);

        if (mark[])

            split(, , R);

        int ans = ;

        for (int i = ; i <= C; ++i)

            ans += am[][i];

        printf("%d\n", ans);

    }

}

int main()

{

    read();

    solve();

    return ;

}

#include<bits/stdc++.h>

using namespace std;

#define MAXR 50000

#define MAXC 15

#define MAXQ 1000

struct SegmentTree {

        int l,r,opt,sum;

} tree[MAXC+][MAXR*+];

int i,j,R,C,Q,R1,R2,C1,C2,X,ans;

char ch;

int mat[MAXR+][MAXC+],sum[MAXR+][MAXC+];

template <typename T> inline void read(T &x) {

    int f = ; x = ;

    char c = getchar();

    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }

    for (; isdigit(c); c = getchar()) x = x *  + c - '';

    x *= f;

}

template <typename T> inline void write(T x) {

    if (x < ) { putchar('-'); x = -x; }

    if (x > ) write(x/);

    putchar(x%+'');

}

template <typename T> inline void writeln(T x) {

    write(x);

    puts("");

}

inline void build(int pos,int index,int l,int r) {

        int mid;

        tree[pos][index].l = l; tree[pos][index].r = r;

        tree[pos][index].sum = r - l +  - sum[r][pos] + sum[l-][pos];

        tree[pos][index].opt = ;

        if (l == r) return;

        mid = (l + r) >> ;

        build(pos,index*,l,mid); build(pos,index*+,mid+,r);

}

inline void pushdown(int pos,int index) {

        int l = tree[pos][index].l,

               r = tree[pos][index].r;

        if (l == r) return;

        tree[pos][index*].opt = tree[pos][index].opt;

        tree[pos][index*+].opt = tree[pos][index].opt;

        l = tree[pos][index*].l,

        r = tree[pos][index*].r;

        if (!tree[pos][index].opt) tree[pos][index*].sum = r - l +  - sum[r][pos] + sum[l-][pos];

        else tree[pos][index*].sum = sum[r][pos] - sum[l-][pos];

        l = tree[pos][index*+].l,

        r = tree[pos][index*+].r;

        if (!tree[pos][index].opt) tree[pos][index*+].sum = r - l +  - sum[r][pos] + sum[l-][pos];

        else tree[pos][index*+].sum = sum[r][pos] - sum[l-][pos];

}

inline void pushup(int pos,int index) {

        tree[pos][index].sum = tree[pos][index*].sum + tree[pos][index*+].sum;

        if ((tree[pos][index*].opt == -) || (tree[pos][index*+].opt == -)) {

                tree[pos][index].opt = -;

                return;

        }

        if (tree[pos][index*].opt != tree[pos][index*+].opt) {

                tree[pos][index].opt = -;

                return;

        }

        tree[pos][index].opt = tree[pos][index*].opt;

}

inline void modify(int pos,int index,int l,int r,int val) {

         int mid;

         if (tree[pos][index].opt != -) pushdown(pos,index);

        if ((tree[pos][index].l == l) && (tree[pos][index].r == r)) {

                tree[pos][index].opt = val;

                if (!val) tree[pos][index].sum = r - l +  - sum[r][pos] + sum[l-][pos];

                else tree[pos][index].sum = sum[r][pos] - sum[l-][pos];

        }    else {

                mid = (tree[pos][index].l + tree[pos][index].r) >> ;

                if (mid >= r) modify(pos,index*,l,r,val);

                else if (mid +  <= l) modify(pos,index*+,l,r,val);

                else {

                        modify(pos,index*,l,mid,val);

                        modify(pos,index*+,mid+,r,val);

                }

                pushup(pos,index);

        }

}

int main() {

        read(R); read(C); read(Q);

        for (i = ; i <= R; i++) {

                for (j = ; j <= C; j++) {

                        ch = getchar();

                        mat[i][j] = ch - '';

                }

                getchar();

        }

        for (i = ; i <= C; i++) {

                for (j = ; j <= R; j++) {

                        sum[j][i] = sum[j-][i] + mat[j][i];

                }

        }

        for (i = ; i <= C; i++) build(i,,,R);

        while (Q--) {

             ans = ;

             read(R1); read(R2); read(C1); read(C2); read(X);

             for (i = C1; i <= C2; i++) modify(i,,R1,R2,X);

             for (i = ; i <= C; i++) ans += tree[i][].sum;

             writeln(ans);

        }

        return ;

}