#include <iostream>
#include <algorithm>
#include <list>
#include <string.h>

#ifdef TEST_MODE
#include <fstream>
#endif

using namespace std;

int t;
int n, m;
int sn, sm;

class Square;
class Light;

Square * squares;
Light * lights;

class Light {
public:
    char stateForTime(int time) {
        return sequence[time % period];
    }
    bool canHorizontally() {
        return sequence[t % period] == '1';
    }
    bool canVertically() {
        return sequence[t % period] == '0';
    }
    char period;
    char sequence[9];
};



class Square {
public:
    int i, j;
    bool occupied = false;
    bool east() {
        if ( j == m)
            return false;
        if ( squares[sm*i + j+1].occupied )
            return false;
        return lightsEast();
    };
    bool west() {
        if ( j == 0)
            return false;
        if ( squares[sm*i + j-1].occupied )
            return false;
        return lightsWest();
    };
    bool north() {
        if ( i == 0)
            return false;
        if ( squares[sm*(i-1) + j].occupied )
            return false;
        return lightsNorth();
    };
    bool south() {
        if ( i == n)
            return false;
        if ( squares[sm*(i+1) + j].occupied )
            return false;
        return lightsSouth();
    }
    bool lightsEast() {
        bool can1, can2;
        if ( i == 0 ) {
            can1 = false;
        } else {
            can1 = lights[(i-1)*m+j].canHorizontally();
        }
        if ( i == n ) {
            can2 = false;
        } else {
            can2 = lights[i*m+j].canHorizontally();
        }
        return can1 || can2;
    }
    
    bool lightsWest() {
        bool can1, can2;
        if ( i == 0 ) {
            can1 = false;
        } else {
            can1 = lights[(i-1)*m+j-1].canHorizontally();
        }
        if ( i == n ) {
            can2 = false;
        } else {
            can2 = lights[i*m+j-1].canHorizontally();
        }
        return can1 || can2;
    }
    
    bool lightsNorth() {
        bool can1, can2;
        if ( j == 0 ) {
            can1 = false;
        } else {
            can1 = lights[(i-1)*m+j-1].canVertically();
        }
        if ( j == m ) {
            can2 = false;
        } else {
            can2 = lights[(i-1)*m+j].canVertically();
        }
        return can1 || can2;
    }
    
    bool lightsSouth() {
        bool can1, can2;
        if ( j == 0 ) {
            can1 = false;
        } else {
            can1 = lights[i*m+j-1].canVertically();
        }
        if ( j == m ) {
            can2 = false;
        } else {
            can2 = lights[i*m+j].canVertically();
        }
        return can1 || can2;
    }
};

int main() {
    
#ifdef TEST_MODE
    std::ifstream in("1.in"); std::cin.rdbuf(in.rdbuf());
#endif
    std::ios_base::sync_with_stdio(false);
    int q;
    cin >> n >> m >> q;
    sn = n + 1;
    sm = m + 1;
    lights = new Light[n*m];
    for ( int i = 0; i < n; ++ i ) {
        for ( int j = 0; j < m; ++j ) {
            Light * l = &lights[i*m+j];
            cin >> l->sequence;
            l->period = strlen(l->sequence);
        }
    }
    
    squares = new Square[(n+1)*(m+1)];
    for ( int i = 0; i <= n; ++i ) {
        for ( int j = 0; j <= m; ++j ) {
            Square * s = &squares[i*sm+j];
            s->i = i; s->j = j; s->occupied = false;
        }
    }
    
    std::list<Square*> squareList;
    std::list<Square*> newSquareList;
    std::list<Square*> iterList;
    while (q--) {
        for ( int i = 0; i <= n; ++i ) {
            for ( int j = 0; j <= m; ++j ) {
                squares[i*sm+j].occupied = false;
            }
        }
        
        squareList.clear();
        
        int i1, j1, i2, j2;
        cin >> t >> i1 >> j1 >> i2 >> j2;
        
        if ( i1 == i2 && j1 == j2 ) {
            cout << t << endl;
        } else {
            t--;
            squares[i1*sn+j1].occupied = true;
            squareList.push_back(&squares[i1*sn+j1]);
            newSquareList = std::list(squareList);
            bool found = false;
            int moved = 0;
            while ( !found ) {
                
                if (moved > 0 ) {
                    moved = 0;
                    iterList = std::list(newSquareList);
                    newSquareList.clear();
                } else {
                    t++;
                    iterList = std::list(squareList);
                }
                auto it = iterList.begin();
               
                while ( it != iterList.end() ) {
                    Square * s = *it;
                    Square * s2;
                    if ( s->north() ) {
                        s2 = &squares[(s->i-1)*sn + s->j];
                        if ( s2->i == i2 && s2->j == j2 ) {
                            found = true;
                            break;
                        } else {
                            moved++;
                            s2->occupied = true;
                            squareList.push_front(s2);
                            newSquareList.push_back(s2);
                        }
                    }
                    if ( s->south() ) {
                        s2 = &squares[(s->i+1)*sn + s->j];
                        if ( s2->i == i2 && s2->j == j2 ) {
                            found = true;
                            break;
                        } else {
                            moved++;
                            s2->occupied = true;
                            squareList.push_front(s2);
                            newSquareList.push_back(s2);
                        }
                    }
                    if ( s->east() ) {
                        s2 = &squares[(s->i)*sn + s->j + 1];
                        if ( s2->i == i2 && s2->j == j2 ) {
                            found = true;
                            break;
                        } else {
                            moved++;
                            s2->occupied = true;
                            squareList.push_front(s2);
                            newSquareList.push_back(s2);
                        }
                    }
                    if ( s->west() ) {
                        s2 = &squares[(s->i)*sn + s->j - 1];
                        if ( s2->i == i2 && s2->j == j2 ) {
                            found = true;
                            break;
                        } else {
                            moved++;
                            s2->occupied = true;
                            squareList.push_front(s2);
                            newSquareList.push_back(s2);
                        }
                    }
                    it++;
                }
            }
            cout << t << endl;
        }
    }
    
    return 0;
}