We've got a rectangular n × m-cell maze. Each cell is either passable, or is a wall (impassable). A little boy found the maze and cyclically tiled a plane with it so that the plane became an infinite maze. Now on this plane cell (x, y) is a wall if and only if cell  is a wall.

In this problem  is a remainder of dividing number a by number b.

The little boy stood at some cell on the plane and he wondered whether he can walk infinitely far away from his starting position. From cell (x, y) he can go to one of the following cells: (x, y - 1), (x, y + 1), (x - 1, y) and (x + 1, y), provided that the cell he goes to is not a wall.

The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 1500) — the height and the width of the maze that the boy used to cyclically tile the plane.

Each of the next n lines contains m characters — the description of the labyrinth. Each character is either a "#", that marks a wall, a ".", that marks a passable cell, or an "S", that marks the little boy's starting point.

The starting point is a passable cell. It is guaranteed that character "S" occurs exactly once in the input.

Print "Yes" (without the quotes), if the little boy can walk infinitely far from the starting point. Otherwise, print "No" (without the quotes).

In the first sample the little boy can go up for infinitely long as there is a "clear path" that goes vertically. He just needs to repeat the following steps infinitely: up, up, left, up, up, right, up.

In the second sample the vertical path is blocked. The path to the left doesn't work, too — the next "copy" of the maze traps the boy.

题意：给出一个n*m的迷宫，在一个平面上有无限个这种迷宫，每个迷宫的上下左右都是完全相同的这种n*m的迷宫（方向和里面的布局都完全一样），也就是说以起始点为原点，所有(x,y)与(x%n,y%m)的内容(不包括‘s’)是相同的（模了数，迷宫在平面上周期性排列，若x<0时要(x%n+n)%n,y<0时同理），比如在这个迷宫走到了边界位置，如果另一个迷宫对应位置没有墙，就可以从另一个迷宫下边界进入，问是否能一直走下去使得离出发点的欧拉距离无限远

思路：以原点为坐标，若能走到无限远处，则在途中必定会在不同的迷宫中经过相同的对应点（有点类似同余模，把当前坐标模了之后可以对应相同的坐标），所以问题就转换为是否能找到不同的坐标有相同的对应点，若有则可以走到无限远，否则就不行

再放个test25的样例，这个要输出Yes

12 12
##.#######.#
#..#......S#
#.#..#######
..#.###.....
##..##..####
#..##..#####
..##..#.....
###..##.####
##..#...####
#..##.######
..##..####..
##...#####.#

 #include<bits/stdc++.h>

 using namespace std;

 const int amn=2e3,inf=0x3f3f3f3f;

 int n,m;

 char mp[amn][amn];

 bool f;

 int dt[][]={{,},{,-},{,},{-,}},stx,sty;

 struct node{

     int x, y;

 };

 node used[amn][amn];

 queue<node> q;

 void bfs(int sx,int sy){

     node a;

     a.x=sx;

     a.y=sy;

     used[sx][sy].x=sx;

     used[sx][sy].y=sy;

     q.push(a);

     int x,y,dx,dy;

     while(q.size()){

         a=q.front();q.pop();

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

             dx=a.x+dt[i][];

             dy=a.y+dt[i][];

             x=(dx%n+n)%n,y=(dy%m+m)%m;    ///把负数坐标变为正数 x=(x%n+n)%n;负数取模会输出负数这时加上模数就是正数的对应值如-6%3=0,(3-0)%3=0,-5%3=-2,(3-2)%3=1,-4%3=-1,(3-1)%3=2...

             //cout<<x<<' '<<y<<endl;

             if(mp[x][y]=='#')continue;

                 if(used[x][y].x==inf){

                 used[x][y].x=dx;

                 used[x][y].y=dy;

                 node po;

                 po.x=dx;

                 po.y=dy;

                 q.push(po);

                 }

                 else if(used[x][y].x!=dx||used[x][y].y!=dy){    ///如果当前坐标模出来后能对应一个不同的坐标，则是可以走到无限远的

                     f=;

                     return ;

                 }

         }

     }

 }

 int main(){

     cin>>n>>m;

     for(int i=;i<n;i++){

         for(int j=;j<m;j++){

             cin>>mp[i][j];

             if(mp[i][j]=='S'){stx=i,sty=j;}

             used[i][j].x=inf;

             used[i][j].y=inf;

         }

     }

     f=;

     bfs(stx,sty);

     if(f)printf("Yes\n");

     else printf("No\n");

 }

 /***

 给出一个n*m的迷宫，在一个平面上有无限个这种迷宫，每个迷宫的上下左右都是完全相同的这种n*m的迷宫（方向和里面的布局都完全一样），

 也就是说以起始点为原点，所有(x,y)与(x%n,y%m)的内容(不包括‘s’)是相同的（模了数，迷宫在平面上周期性排列，若x<0时要(x%n+n)%n,y<0时同理），

 比如在这个迷宫走到了边界位置，如果另一个迷宫对应位置没有墙，就可以从另一个迷宫下边界进入，问是否能一直走下去使得离出发点的欧拉距离无限远

 以原点为坐标，若能走到无限远处，则在途中必定会在不同的迷宫中经过相同的对应点（有点类似同余模，把当前坐标模了之后可以对应相同的坐标），所以问题就转换为

 是否能找到不同的坐标有相同的对应点，若有则可以走到无限远，否则就不行

 ***/