光（mirror room）

/*

光线只有遇上边界或堵塞的格子才会改变方向，所以改变方向的位置是有限的，光线的方向又最多只有四种，所以光线在循环之前改变方向的次数是O（n+m+k）级别的。我们可以模拟光线的移动。已知光线位置和光线的方向，使用二分的方法可以在O（log k）的时间复杂度内求出即将改变方向的位置和改变后的方向。

我们暂把光线的位置和方向称为光线的状态。一种状态能转移到一种且仅有一种状态。如果从状态a能转移到状态b，那么b反向后的状态能转移到a反向后的状态。所以一种状态能从一种且仅有一种状态转移而来。这就像是一种置换，所以从初始状态出发，必定会回到初始状态，并且回到初始状态之前不会重复经过某种状态。

我们对网格进行染色，有邻边的格子颜色不同，形成一个二分图。根据题目中光线反射的方式，可以发现，每当光线沿西北、东南方向前进时，只会经过一种颜色的网格，每当光线沿东北、西南方向前进时，只会经过另一种颜色的网格。所以光线在某一个格子中心时，要么只会是西北、东南方向之一，要么只会是东北、西南方向之一。

这样，如果一次循环内一个格子被重复经过，只有可能是光线以相反的两个方向进入，并且一次循环内一个格子最多被经过两次。一个格子被经过两次，所有被光线经过的格子都会被经过两次。易知，如果光线在前进过程中出现过如下两种反射，所有格子就会被经过两次。只需在模拟的过程中记录是否出现过这两种情况即可。*/

 #include<bits/stdc++.h>
 #define re register
 #define int long long
 using namespace std;
 int n,m,k,x,y,direct,ans; char s[];
 set<int> s1[],s2[];
 map< pair<int,int>,bool>mp;
 struct node{int x,y,direct;}now;
 inline int read(){
     re int a=,b=; re char ch=getchar();
     while(ch<''||ch>'')
         b=(ch=='-')?-:,ch=getchar();
     while(ch>=''&&ch<='')
         a=(a<<)+(a<<)+(ch^),ch=getchar();
     return a*b;
 }
 inline pair<node,int> cal(node x){
     node k;
     set<int>::iterator data;
     switch(x.direct)
     {
         case :
         {
             data=s1[x.x-x.y+m+].lower_bound(x.x);data--;
             k.x=x.x-abs(*data-x.x)+;
             k.y=x.y-abs(*data-x.x)+;
             if(mp[make_pair(k.x-,k.y)]&&mp[make_pair(k.x,k.y-)])k.direct=;
             else if(mp[make_pair(k.x-,k.y)]){k.y--,k.direct=;}
             else if(mp[make_pair(k.x,k.y-)]){k.x--,k.direct=;}
             else k.direct=;
             break;

         }
         case :
         {
             data=s2[x.x+x.y].lower_bound(x.x);data--;
             k.x=x.x-abs(*data-x.x)+;
             k.y=x.y+abs(*data-x.x)-;
             if(mp[make_pair(k.x-,k.y)]&&mp[make_pair(k.x,k.y+)])k.direct=;
             else if(mp[make_pair(k.x-,k.y)]){k.y++,k.direct=;}
             else if(mp[make_pair(k.x,k.y+)]){k.x--,k.direct=;}
             else k.direct=;
             break;
         }
         case :
         {
             data=s1[x.x-x.y+m+].lower_bound(x.x);
             k.x=x.x+abs(*data-x.x)-;
             k.y=x.y+abs(*data-x.x)-;
             if(mp[make_pair(k.x+,k.y)]&&mp[make_pair(k.x,k.y+)])k.direct=;
             else if(mp[make_pair(k.x+,k.y)]){k.y++,k.direct=;}
             else if(mp[make_pair(k.x,k.y+)]){k.x++,k.direct=;}
             else k.direct=;
             break;
         }
         case :
         {
             data=s2[x.x+x.y].lower_bound(x.x);
             k.x=x.x+abs(*data-x.x)-;
             k.y=x.y-abs(*data-x.x)+;
             if(mp[make_pair(k.x+,k.y)]&&mp[make_pair(k.x,k.y-)])k.direct=;
             else if(mp[make_pair(k.x+,k.y)]){k.y--,k.direct=;}
             else if(mp[make_pair(k.x,k.y-)]){k.x++,k.direct=;}
             else k.direct=;
             break;
         }
     }
     return make_pair(k,abs(*data-x.x));
 }
 inline bool judge(node x){
     node k=x;
     do{
         pair<node,int> l=cal(x);
         ans+=l.second;
         switch(l.first.direct)
         {
             case :if(x.direct==)return ;break;
             case :if(x.direct==)return ;break;
             case :if(x.direct==)return ;break;
             case :if(x.direct==)return ;break;
         }
         x=l.first;
     }while(k.x!=x.x||k.y!=x.y||k.direct!=x.direct);
     return ;
 }
 signed main(){
     n=read(),m=read(),k=read();
     for(re int i=,u,v;i<=k;i++){
         u=read(),v=read();
         s1[u-v+m+].insert(u);
         s2[u+v].insert(u);
         mp[make_pair(u,v)]=;
     }
     for(re int i=;i<=m+;i++){
         s1[m+-i].insert();
         s2[i].insert();
         s1[m+n-i+].insert(n+);
         s2[i+n+].insert(n+);
         mp[make_pair(,i)]=;
         mp[make_pair(n+,i)]=;
     }
     for(re int i=;i<=n;i++){
         s1[i+m+].insert(i);
         s2[i].insert(i);
         s1[i].insert(i);
         s2[i+m+].insert(i);
         mp[make_pair(i,)]=;
         mp[make_pair(i,m+)]=;
     }
     x=read(),y=read();scanf("%s",s);
     if(s[]=='N'&&s[]=='W') direct=;
     if(s[]=='N'&&s[]=='E') direct=;
     if(s[]=='S'&&s[]=='E') direct=;
     if(s[]=='S'&&s[]=='W') direct=;
     now.x=x,now.y=y,now.direct=direct;
     now=cal(now).first;
     if(!judge(now))
     {
         ans--;
         switch(now.direct)
         {
             case :now.direct=;break;
             case :now.direct=;break;
             case :now.direct=;break;
             case :now.direct=;break;
         }
         judge(now);
     }
     printf("%lld\n",ans);
 }