// Znajdowanie wyjścia z labiryntu
// Data: 25.08.2013
// (C)2013 mgr Jerzy Wałaszek
//--------------------------------
//Skorzystałem z powyższego

#include <iostream>
#include <string>

using namespace std;

const int MAXINT = -2147483647;
//const long long MAXINT = -9223372036854775807;




// Typy dla kolejki

struct slistEl
{
  slistEl * next;
  int v;
};

// Definicja typu obiektowego queue
//---------------------------------
class queue
{
  private:
    slistEl * head;
    slistEl * tail;

  public:
    queue( );      // konstruktor
    ~queue( );     // destruktor
    bool empty ( void );
    int  front ( void );
    void push ( int v );
    void pop ( void );
};

//---------------------
// Metody obiektu queue
//---------------------

// Konstruktor - tworzy pustą listę
//---------------------------------
queue::queue( )
{
  head = tail = NULL;
}

// Destruktor - usuwa listę z pamięci
//-----------------------------------
queue::~queue( )
{
  while( head ) pop( );
}

// Sprawdza, czy kolejka jest pusta
//---------------------------------
bool queue::empty ( void )
{
  return !head;
}

// Zwraca początek kolejki.
// Wartość specjalna to -MAXINT
//-----------------------------
int queue::front ( void )
{
  if( head ) return head->v;
  else     return -MAXINT;
}

// Zapisuje do kolejki
//--------------------
void queue::push ( int v )
{
  slistEl * p = new slistEl;
  p->next = NULL;
  p->v = v;
  if( tail ) tail->next = p;
  else     head = p;
  tail = p;
}

// Usuwa z kolejki
//----------------
void queue::pop ( void )
{
  if( head )
  {
    slistEl * p = head;
    head = head->next;
    if( !head ) tail = NULL;
    delete p;
  }
}

// Zmienne globalne
//-----------------

int wst, kst;  // Współrzędne startowe - wiersz, kolumna
int wwy, kwy;  // Współrzędne wyjścia  - wiersz, kolumna
int n = 2003;    // Liczba wierszy
string * L = new string [ n ];  // Labirynt

long long wgore, gora;
long long wdol, dol;
int osoby;

// Odczytuje labirynt
// Wyszukuje wierzchołki
// startowy i wyjściowy
//----------------------
void czytajL( )
{
  string s, * T;
  int i, j;

//  i = 0;            // Licznik wierszy
//  do
//  {
//    cin >> s;       // Czytamy wiersz z wejścia
//    if( s != "*" )  // Jeśli nie jest to wiersz końcowy, to
//    {
//      if( n < i+1 ) // ustawiamy rozmiar tablicy
//      {
//        T = new string [ i + 10 ];
//        for( j = 0; j < n; j++ ) T [ j ] = L [ j ];
//        delete [ ] L;
//        L = T;
//        n = i + 10;
//      }
//      L [ i++ ] = s; // odczytany wiersz umieszczamy w tablicy M
	  
//	  cout << s << endl;;
	  
//    }
//  } while( s != "*" );

//cout << endl;

int ww, kk;

cin >> ww >> kk >> osoby;

for (int x=1; x<ww+1; x++)
  {
  cin >> s;
  L[x]=s;
  }

L[1][0]='S';
L[ww][kk]='W';

L[0]=L[1];
for ( j = 0; j < ( int )L [ i ].length( ); j++ )
  L[0][j]='X';
L[ww+1]=L[0];
for (int x=0; x<ww+2; x++)
  L[x]='X'+L[x]+'X';



  for( i = 0; i < n; i++ )
    for( j = 0; j < ( int )L [ i ].length( ); j++ )
      if( L [ i ][ j ] == ' ' )
	    L [i][j]='.';
  
for (int x=0; x<ww+2; x++)
//  {
//  cout << L[x] << endl;
//  cout << L[x].length() << endl;
//  }  

//  n = i; // Liczba wierszy w L
  n=ww;
//  wst = kst = wwy = kwy = -1; // Współrzędne startu oraz wyjścia

//  for( i = 0; i < n; i++ )  // Szukamy S i W
  
//    for( j = 0; j < ( int )L [ i ].length( ); j++ )
	
//      if( L [ i ][ j ] == 'S' )
//      {
//        wst = i; kst = j;   // S znalezione
//      }
//      else if( L [ i ][ j ] == 'W' )
//      {
//        wwy = i; kwy = j;   // W znalezione
//        L [ i ][ j ] = '.';
//      }

//  wst = 0;
//  kst = 0;
  wst=1;
  kst=1;
//  wwy = ww-2;
//  kwy = kk-2;
  wwy=ww;
  kwy=kk;
  L [ wwy ][ kwy ] = '.';  

//cout << wst << kst << wwy << kwy << endl;

}

// Procedura szukania wyjścia
//---------------------------
void SzukajW( )
{
  queue Q;
  int w, k;       // Wiersz, kolumna bieżącego wierzchołka
  int i, j;

  Q.push ( wst ); // W kolejce umieszczamy wierzchołek startowy
  Q.push ( kst );

  while( !Q.empty( ) )
  {
    w = Q.front( ); Q.pop( );  // Pobieramy z kolejki wiersz
    k = Q.front( ); Q.pop( );  // i kolumnę bieżącego wierzchołka

    // Sprawdzamy, czy osiągnęliśmy wyjście

    if( ( w == wwy ) && ( k == kwy ) ) break;

    // Przeglądamy sąsiadów bieżącego wierzchołka

    for( i = -1; i <= 1; i++ )
      for( j = -1; j <= 1; j++ )
        if( ( i != j ) && ( !i || !j ) )
        {
          if( L [ w + i ][ k + j ] == '.' )
          {
            // W komórce sąsiada zapisujemy, skąd przyszliśmy do niej

            if(      i == -1 ) L [ w + i ][ k + j ] = 'd';  // z dołu
            else if( i ==  1 ) L [ w + i ][ k + j ] = 'g';  // z góry
            else if( j == -1 ) L [ w + i ][ k + j ] = 'p';  // z prawej
            else               L [ w + i ][ k + j ] = 'l';  // z lewej

            Q.push ( w + i );  // Sąsiad zostaje umieszczony w kolejce
            Q.push ( k + j );
          }
        }
  }
}

// Procedura wypisuje labirynt z ewentualną ścieżką
// Zastępuje znaki kierunków znakiem -.
//-------------------------------------------------
void PiszL( )
{
  int i, j;
  char c;

  // Najpierw sprawdzamy, czy ścieżka została znaleziona
  // Jeśli tak, to zastępujemy ją znakami +

//  for( i = 0; i < n+2; i++ )  // było n
//  {
//     cout << L [ i ] << endl;
//  }
//  cout << endl;


  if( L [ wwy ][ kwy ] != '.' )
  {
    i = wwy; j = kwy;

    while( ( i != wst ) || ( j != kst ) )
    {
      c = L [ i ][ j ];
      L [ i ][ j ] = '+';
      switch ( c )
      {
        case 'd' : i++; wdol=wdol+1; break;
        case 'g' : i--; wgore=wgore+1; break;
        case 'p' : j++; wdol=wdol+1; break;
        case 'l' : j--; wgore=wgore+1; break;
      }
    }
  }

  L [ wwy ][ kwy ] = 'W'; // Odtwarzamy znak wyjścia


//  for( i = 0; i < n+2; i++ )  // było n
//  {
//     cout << L [ i ] << endl;
//  }
//  cout << endl;


  // Teraz usuwamy znaki kierunku i wypisujemy labirynt

  for( i = 0; i < n+2; i++ )  // było n
  {
    for( j = 0; j < ( int )L [ i ].length( ); j++ )
      switch( L [ i ][ j ] )
      {
        case 'g': ;
        case 'd': ;
        case 'p': ;
        case 'l': L [ i ][ j ] = ' ';
      }
//    cout << L [ i ] << endl;
  }
//  cout << endl;
}

// **********************
// *** PROGRAM GŁÓWNY ***
// **********************

int main( )
{

  long long min;
  int ile;
  
  czytajL( );    // Wczytujemy labirynt

  if( ( wst == -1 ) || ( kst == -1 ) || ( wwy == -1 ) || ( kwy == -1 ) )
    cout << "BRAK DEFINICJI S LUB W !!!\n";
  else
  {
    SzukajW( ); // Szukamy wyjścia
	
	wgore=0;
	wdol=0;
    min=9223372036854775807;
//	min=18446744073709551615;
	ile=0;
	
    PiszL( );   // Wyświetlamy wyniki poszukiwań

    for (int x=1; x<=osoby; x++)
      {
      cin >> gora >> dol;
//      cout << gora*wgore+dol*wdol << endl;
	  if (gora*wgore+dol*wdol<=min)
	    if (gora*wgore+dol*wdol==min)
		{
		ile=ile+1;
		}
      else
	    {
		min=gora*wgore+dol*wdol;
        ile=1;
		}
		
//cout << wgore << " " <<gora << endl;
//cout << wdol << " " << dol << endl;
//cout << gora*wgore << " " << dol*wdol << " " << min << endl;
		
      };

    cout << min << " " << ile;

   }
  return 0;
}