import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Whiteboard
 * 
 * @author vanb
 */
public class whiteboard_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * A Max Segment Tree.
     * 
     * @author vanb
     */
    public class SegmentTree
    {
        /** The number of elements */
        public int size;
        
        /** The tree itself */
        public int tree[];
        
        /**
         * Create a Segment Tree for a segment with 'size' elements.
         * 
         * @param size Number of elements
         */
        public SegmentTree( int size )
        {
            this.size = size;
            
            // If there are n elements, then the number of leaves
            // in the Segment Tree could be up to k, where k is the smallest
            // power of 2 greater than or equal to n.
            int k = Integer.highestOneBit( size );
            if( k!=size ) k<<=1;
            
            // A binary tree with k leaves will have k-1 internal nodes.
            // So, we need k+k-1 overall. But, we start at 1, not 0, so
            // we need one more, since there's one (at 0) we won't use.
            tree = new int[k + k];
            
            // We're use -1 as a flag that a value hasn't been set here.
            Arrays.fill( tree, -1 );
        }
        
        /**
         * Put a value over an interval into the Segment tree.
         * This is an internal method.
         * 
         * @param node Index of the current node
         * @param lo Low index of the segment for this node
         * @param hi High index of the segment for this node
         * @param lower Lower bound of the interval of interest
         * @param upper Upper bound of the interval of interest
         * @param value Value to fill in the interval [lower,upper]
         */
        private void put( int node, int lo, int hi, int lower, int upper, int value )
        {
            if( lower<=lo && hi<=upper )
            {
                tree[node] = value;
            }
            else
            {
                // Build left and right subtrees
                int mid = (hi+lo)/2;
                if( lower<=mid ) put( node+node, lo, mid, lower, upper, value );
                if( upper>mid ) put( node+node+1, mid+1, hi, lower, upper, value  );
            }
        }
        
        /**
         * Put a value over an interval into the Segment tree.
         * This is an outward facing method.
         * 
         * @param lower Lower bound of the interval of interest
         * @param upper Upper bound of the interval of interest
         * @param value Value to fill in the interval [lower,upper]
         */
        public void put( int lower, int upper, int value )
        {
            put( 1, 0, size-1, lower, upper, value );
        }
        
        /**
         * Get a value from the Segment Tree.
         * This is an internal method.
         * 
         * @param node Index of the current node
         * @param lo Low index of the segment for this node
         * @param hi High index of the segment for this node
         * @param index Index we want to get the value from
         * @return
         */
        private int get( int node, int lo, int hi, int index )
        {
            int result = -1;
            if( node<tree.length )
            {
                int mid = (lo+hi)/2;
                result = Math.max( tree[node], 
                        (index<=mid) ? get( node+node, lo, mid, index ) : get( node+node+1, mid+1, hi, index) );
            }
            return result;
        }
        
        /**
         * Get a value from the Segment Tree.
         * This is an outward facing method.
         * 
         * @param index Index we want to get the value from
         * @return
         */
        public int get( int index )
        {
            return get( 1, 0, size-1, index );
        }
    }
    
    /**
     * Class to hold the effects of a Command.
     * 
     * @author vanb
     */
    public class Command
    {
        /** Basr starting point of the marker when this command is execited */
        public int i, j;
        
        /** Second at which the marker is at (i,j) */
        public long second;
        
        /**
         * Build a Command.
         * 
         * @param i i-coord of base point
         * @param j j-coord of base point
         * @param second Second at which command is executed
         */
        public Command( int i, int j, long second )
        {
            this.i = i;
            this.j = j;
            this.second = second;
        }
        
        /**
         * Get the time when the marker is at (i,j) executing this Command.
         * 
         * @param i i-coord of query point
         * @param j j-coord of query point
         * @return Time when the marker is at (i,j) executing this Command
         */
        public long timeAt( int i, int j )
        {
            // This is a little tricky (and lazy).
            // The marker only moves up, down, left or right.
            // So, one of |this.i - i| and |this.j - j| will be zero.
            // The other will be the distance moved. That'll be true
            // no matter which direction the marker is moving.
            return second + Math.abs( this.i - i ) + Math.abs( this.j - j );
        }
        
        /**
         * Create pretty sString for debugging.
         */
        public String toString()
        {
            return "{i,j=" + i + "," + j + " second=" + second + "}";
        }
    }
    
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;  
        
        int h = sc.nextInt();
        int w = sc.nextInt();
        int n = sc.nextInt();
        
        // Read in the target
        // target[i][j] is either '#' or '.', depending on Mr. Turtle's desire.
        // '#' means there's a mark there, '.' means blank.
        char target[][] = new char[h][];
        for( int i=0; i<h; i++ ) target[i] = sc.next().toCharArray();
        
        // Create a Segment Tree for each row
        SegmentTree rows[] = new SegmentTree[h];
        for( int i=0; i<h; i++ ) rows[i] = new SegmentTree(w);
        
        // Create a Segment Tree for each column
        SegmentTree cols[] = new SegmentTree[w];
        for( int j=0; j<w; j++ ) cols[j] = new SegmentTree(h);
        
        // Simulate Mr. Turtle's commands, recording the effects.
        // This is the lower left corner, where we start.
        int i=h-1, j=0;
        
        // We're here at the 1st second.
        long seconds = 1L;
        
        // Create the effects of the Commands.
        Command commands[] = new Command[n+1];
        
        // The lower left hand corner, where the marker starts, gets marked,
        // without an explicit command. so it needs a special implicit "command"
        commands[0] = new Command( 0, 0, 1L );
        rows[h-1].put( 0, 0, 0 );
        cols[0].put( h-1, h-1, 0 );
        
        // Execute the Commands.
        for( int k=1; k<=n; k++ )
        {
            char direction = sc.next().charAt( 0 );
            int distance = sc.nextInt();
            
            // Record the command
            commands[k] = new Command( i, j, seconds );

            // Put the command in the Segment Trees.
            // We'll use Segment Trees to handle each command
            // in one fell swoop. We can't iterate second by second, it would be too slow.
            switch( direction )
            {
                case 'u' : cols[j].put( i-distance, i-1, k ); i -= distance; break;                
                case 'd' : cols[j].put( i+1, i+distance, k ); i += distance; break;              
                case 'l' : rows[i].put( j-distance, j-1, k ); j -= distance; break;                
                case 'r' : rows[i].put( j+1, j+distance, k ); j += distance; break;
                default  : System.err.println( "PANIC!! Unknown direction: " + direction);
            }    
            
            seconds += distance;
        }
        
        // Now, go through Mr. Turtle's target drawing 
        boolean impossible = false;
        long lowest = 0L;
        long highest = seconds;
        for( i=0; i<h; i++ ) for( j=0; j<w; j++ )
        {            
            // Retrieve the highest numbered (last) command that went through this spot
            int command = Math.max( rows[i].get(j), cols[j].get(i) );
            
            // Use that to figure out the last time the marker went through here
            long max = command<0 ? -1 : commands[command].timeAt( i, j );

            if( target[i][j]=='#' )
            {
                // There is a mark on the whiteboard here in Mr. Turtle's target.
                // If the marker never went here, it's impossible
                if( max<0 ) impossible = true;
                // Otherwise, whenever the marker went through here last,
                // it has to dry out some time later.
                else lowest = Math.max( lowest, max );
            }
            else
            {
                // There's no mark on the whiteboard here in Mr. Turtle's target.
                // If the marker never went through here, well, no prob.
                // If it did, then it must have dried out some time before.
                if( max>0 ) highest = Math.min( highest, max-1 );
            }
        }
        
        if( highest<lowest ) impossible = true;
        ps.println( impossible ? "-1 -1" : ( "" + lowest + " " + highest ) );  
     }
        
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new whiteboard_vanb().doit();
    }   
}