#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039];
bool use[1039][1039][4];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	t[sx][sy]=0,use[sx][sy][0]=use[sx][sy][1]=use[sx][sy][2]=use[sx][sy][3]=1;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(s.x==ex && s.y==ey)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(use[s.x][s.y][0])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x-a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][1]=1;
					que.push((poi){s.x-a,s.y});
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][3]=1;
					que.push((poi){s.x-a,s.y});
				}
			}
			if(a>k && s.x-k>0)
			{
				t[s.x-k][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				use[s.x-k][s.y][0]=1;
				que.push((poi){s.x-k,s.y});
			}
		}
		if(use[s.x][s.y][1])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y-a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][0]=1;
					que.push((poi){s.x,s.y-a});
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][2]=1;
					que.push((poi){s.x,s.y-a});
				}
			}
			if(a>k && s.y-k>0)
			{
				t[s.x][s.y-k]=min(t[s.x][s.y-k],t[s.x][s.y]+1);
				use[s.x][s.y-k][1]=1;
				que.push((poi){s.x,s.y-k});
			}
		}
		if(use[s.x][s.y][2])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x+a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][1]=1;
					que.push((poi){s.x+a,s.y});
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][3]=1;
					que.push((poi){s.x+a,s.y});
				}
			}
			if(a>k && s.x+k<n)
			{
				t[s.x+k][s.y]=min(t[s.x+k][s.y],t[s.x][s.y]+1);
				use[s.x+k][s.y][2]=1;
				que.push((poi){s.x+k,s.y});
			}
		}
		if(use[s.x][s.y][3])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y+a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][0]=1;
					que.push((poi){s.x,s.y+a});
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][2]=1;
					que.push((poi){s.x,s.y+a});
				}
			}
			if(a>k && s.y+k<m)
			{
				t[s.x][s.y+k]=min(t[s.x][s.y+k],t[s.x][s.y]+1);
				use[s.x][s.y+k][3]=1;
				que.push((poi){s.x,s.y+k});
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039],flag;
bool in[1039][1039][4];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy][0]=in[sx][sy][1]=in[sx][sy][2]=in[sx][sy][3]=1;
	t[sx][sy]=0;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(flag)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(in[s.x][s.y][0])
		{
			for(a=1;a<=k && s.x-a;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x-a][s.y]!='.' || (t[s.x-a][s.y]<t[s.x][s.y]+1 && in[s.x-a][s.y][0]))
				{
					break;
				}
				t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				if(ch[s.x-a][s.y-1]=='.')
				{
					if(!in[s.x-a][s.y][1])
					{
						in[s.x-a][s.y][1]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					if(!in[s.x-a][s.y][3])
					{
						in[s.x-a][s.y][3]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k)
			{
				if(!in[s.x-k][s.y][0])
				{
					in[s.x-k][s.y][0]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(in[s.x][s.y][1])
		{
			for(a=1;a<=k && s.y-a;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x][s.y-a]!='.' || (t[s.x][s.y-a]<t[s.x][s.y]+1 && in[s.x][s.y-a][1]))
				{
					break;
				}
				t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
				if(ch[s.x-1][s.y-a]=='.')
				{
					if(!in[s.x][s.y-a][0])
					{
						in[s.x][s.y-a][0]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					if(!in[s.x][s.y-a][2])
					{
						in[s.x][s.y-a][2]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k)
			{
				if(!in[s.x][s.y-k][1])
				{
					in[s.x][s.y-k][1]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(in[s.x][s.y][2])
		{
			for(a=1;a<=k && s.x+a<=n;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x+a][s.y]!='.' || (t[s.x+a][s.y]<t[s.x][s.y]+1 && in[s.x+a][s.y][2]))
				{
					break;
				}
				t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
				if(ch[s.x+a][s.y-1]=='.')
				{
					if(!in[s.x+a][s.y][1])
					{
						in[s.x+a][s.y][1]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					if(!in[s.x+a][s.y][3])
					{
						in[s.x+a][s.y][3]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<=n)
			{
				if(!in[s.x+k][s.y][2])
				{
					in[s.x+k][s.y][2]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(in[s.x][s.y][3])
		{
			for(a=1;a<=k && s.y+a<=m;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x][s.y+a]!='.' || (t[s.x][s.y+a]<t[s.x][s.y]+1 && in[s.x][s.y+a][3]))
				{
					break;
				}
				t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
				if(ch[s.x-1][s.y+a]=='.')
				{
					if(!in[s.x][s.y+a][0])
					{
						in[s.x][s.y+a][0]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					if(!in[s.x][s.y+a][2])
					{
						in[s.x][s.y+a][2]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<=m)
			{
				if(!in[s.x][s.y+k][3])
				{
					in[s.x][s.y+k][3]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039];
bool use[1039][1039][4],in[1039][1039];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy]=1;
	t[sx][sy]=0,use[sx][sy][0]=use[sx][sy][1]=use[sx][sy][2]=use[sx][sy][3]=1;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(s.x==ex && s.y==ey)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(use[s.x][s.y][0])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x-a][s.y]!='.' || in[s.x-a][s.y])
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][1]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][3]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k>0)
			{
				t[s.x-k][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				use[s.x-k][s.y][0]=1;
				if(!in[s.x-k][s.y])
				{
					in[s.x-k][s.y]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(use[s.x][s.y][1])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y-a]!='.' || in[s.x][s.y-a])
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][0]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][2]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k>0)
			{
				t[s.x][s.y-k]=min(t[s.x][s.y-k],t[s.x][s.y]+1);
				use[s.x][s.y-k][1]=1;
				if(!in[s.x][s.y-k])
				{
					in[s.x][s.y-k]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(use[s.x][s.y][2])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x+a][s.y]!='.' || in[s.x+a][s.y])
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][1]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][3]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<n)
			{
				t[s.x+k][s.y]=min(t[s.x+k][s.y],t[s.x][s.y]+1);
				use[s.x+k][s.y][2]=1;
				if(!in[s.x+k][s.y])
				{
					in[s.x+k][s.y]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(use[s.x][s.y][3])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y+a]!='.' || in[s.x][s.y+a])
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][0]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][2]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<m)
			{
				t[s.x][s.y+k]=min(t[s.x][s.y+k],t[s.x][s.y]+1);
				use[s.x][s.y+k][3]=1;
				if(!in[s.x][s.y+k])
				{
					in[s.x][s.y+k]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039];
bool use[1039][1039][4],in[1039][1039];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy]=1;
	t[sx][sy]=0,use[sx][sy][0]=use[sx][sy][1]=use[sx][sy][2]=use[sx][sy][3]=1;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(s.x==ex && s.y==ey)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(use[s.x][s.y][0])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x-a][s.y]!='.')
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][1]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][3]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k>0)
			{
				t[s.x-k][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				use[s.x-k][s.y][0]=1;
				if(!in[s.x-k][s.y])
				{
					in[s.x-k][s.y]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(use[s.x][s.y][1])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y-a]!='.')
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][0]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][2]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k>0)
			{
				t[s.x][s.y-k]=min(t[s.x][s.y-k],t[s.x][s.y]+1);
				use[s.x][s.y-k][1]=1;
				if(!in[s.x][s.y-k])
				{
					in[s.x][s.y-k]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(use[s.x][s.y][2])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x+a][s.y]!='.')
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][1]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][3]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<n)
			{
				t[s.x+k][s.y]=min(t[s.x+k][s.y],t[s.x][s.y]+1);
				use[s.x+k][s.y][2]=1;
				if(!in[s.x+k][s.y])
				{
					in[s.x+k][s.y]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(use[s.x][s.y][3])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y+a]!='.')
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][0]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][2]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<m)
			{
				t[s.x][s.y+k]=min(t[s.x][s.y+k],t[s.x][s.y]+1);
				use[s.x][s.y+k][3]=1;
				if(!in[s.x][s.y+k])
				{
					in[s.x][s.y+k]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039],flag;
bool in[1039][1039][4];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	if(sx==ex && sy==ey)
	{
		flag=1;
	}
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy][0]=in[sx][sy][1]=in[sx][sy][2]=in[sx][sy][3]=1;
	t[sx][sy]=0;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(flag)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(in[s.x][s.y][0])
		{
			for(a=1;a<=k && s.x-a;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x-a][s.y]!='.' || (t[s.x-a][s.y]<t[s.x][s.y]+1 && in[s.x-a][s.y][0]))
				{
					break;
				}
				t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				if(ch[s.x-a][s.y-1]=='.')
				{
					if(!in[s.x-a][s.y][1])
					{
						in[s.x-a][s.y][1]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					if(!in[s.x-a][s.y][3])
					{
						in[s.x-a][s.y][3]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k)
			{
				if(!in[s.x-k][s.y][0])
				{
					in[s.x-k][s.y][0]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(in[s.x][s.y][1])
		{
			for(a=1;a<=k && s.y-a;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x][s.y-a]!='.' || (t[s.x][s.y-a]<t[s.x][s.y]+1 && in[s.x][s.y-a][1]))
				{
					break;
				}
				t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
				if(ch[s.x-1][s.y-a]=='.')
				{
					if(!in[s.x][s.y-a][0])
					{
						in[s.x][s.y-a][0]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					if(!in[s.x][s.y-a][2])
					{
						in[s.x][s.y-a][2]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k)
			{
				if(!in[s.x][s.y-k][1])
				{
					in[s.x][s.y-k][1]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(in[s.x][s.y][2])
		{
			for(a=1;a<=k && s.x+a<=n;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x+a][s.y]!='.' || (t[s.x+a][s.y]<t[s.x][s.y]+1 && in[s.x+a][s.y][2]))
				{
					break;
				}
				t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
				if(ch[s.x+a][s.y-1]=='.')
				{
					if(!in[s.x+a][s.y][1])
					{
						in[s.x+a][s.y][1]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					if(!in[s.x+a][s.y][3])
					{
						in[s.x+a][s.y][3]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<=n)
			{
				if(!in[s.x+k][s.y][2])
				{
					in[s.x+k][s.y][2]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(in[s.x][s.y][3])
		{
			for(a=1;a<=k && s.y+a<=m;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					flag=1,que.push((poi){ex,ey});
					break;
				}
				if(ch[s.x][s.y+a]!='.' || (t[s.x][s.y+a]<t[s.x][s.y]+1 && in[s.x][s.y+a][3]))
				{
					break;
				}
				t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
				if(ch[s.x-1][s.y+a]=='.')
				{
					if(!in[s.x][s.y+a][0])
					{
						in[s.x][s.y+a][0]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					if(!in[s.x][s.y+a][2])
					{
						in[s.x][s.y+a][2]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<=m)
			{
				if(!in[s.x][s.y+k][3])
				{
					in[s.x][s.y+k][3]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y,sl;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy,1});
	que.push((poi){sx,sy,2});
	que.push((poi){sx,sy,3});
	que.push((poi){sx,sy,4});
	t[sx][sy]=0;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(s.x==ex && s.y==ey)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(s.sl==1)
		{
			for(a=1;a<=k;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey,0});
				}
				if(ch[s.x-a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					que.push((poi){s.x-a,s.y,2});
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					que.push((poi){s.x-a,s.y,4});
				}
			}
			if(a>k && s.x-k>0)
			{
				t[s.x-k][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				que.push((poi){s.x-k,s.y,1});
			}
		}
		if(s.sl==2)
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey,0});
				}
				if(ch[s.x][s.y-a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					que.push((poi){s.x,s.y-a,1});
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					que.push((poi){s.x,s.y-a,3});
				}
			}
			if(a>k && s.y-k>0)
			{
				t[s.x][s.y-k]=min(t[s.x][s.y-k],t[s.x][s.y]+1);
				que.push((poi){s.x,s.y-k,2});
			}
		}
		if(s.sl==3)
		{
			for(a=1;a<=k;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey,0});
				}
				if(ch[s.x+a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					que.push((poi){s.x+a,s.y,2});
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					que.push((poi){s.x+a,s.y,4});
				}
			}
			if(a>k && s.x+k<n)
			{
				t[s.x+k][s.y]=min(t[s.x+k][s.y],t[s.x][s.y]+1);
				que.push((poi){s.x+k,s.y,3});
			}
		}
		if(s.sl==4)
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey,0});
				}
				if(ch[s.x][s.y+a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					que.push((poi){s.x,s.y+a,1});
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					que.push((poi){s.x,s.y+a,3});
				}
			}
			if(a>k && s.y+k<m)
			{
				t[s.x][s.y+k]=min(t[s.x][s.y+k],t[s.x][s.y]+1);
				que.push((poi){s.x,s.y+k,4});
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039],flag;
bool in[1039][1039][4];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy][0]=in[sx][sy][1]=in[sx][sy][2]=in[sx][sy][3]=1;
	t[sx][sy]=0;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(flag)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(in[s.x][s.y][0])
		{
			for(a=1;a<=k && s.x-a;a++)
			{
				t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				if(s.x-a==ex && s.y==ey)
				{
					flag=1;
					break;
				}
				if(ch[s.x-a][s.y]!='.' || in[s.x-a][s.y][0])
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					if(!in[s.x-a][s.y][1])
					{
						in[s.x-a][s.y][1]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					if(!in[s.x-a][s.y][3])
					{
						in[s.x-a][s.y][3]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k)
			{
				if(!in[s.x-k][s.y][0])
				{
					in[s.x-k][s.y][0]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(in[s.x][s.y][1])
		{
			for(a=1;a<=k && s.y-a;a++)
			{
				t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
				if(s.x==ex && s.y-a==ey)
				{
					flag=1;
					break;
				}
				if(ch[s.x][s.y-a]!='.' || in[s.x][s.y-a][1])
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					if(!in[s.x][s.y-a][0])
					{
						in[s.x][s.y-a][0]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					if(!in[s.x][s.y-a][2])
					{
						in[s.x][s.y-a][2]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k)
			{
				if(!in[s.x][s.y-k][1])
				{
					in[s.x][s.y-k][1]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(in[s.x][s.y][2])
		{
			for(a=1;a<=k && s.x+a<=n;a++)
			{
				t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
				if(s.x+a==ex && s.y==ey)
				{
					flag=1;
					break;
				}
				if(ch[s.x+a][s.y]!='.' || in[s.x+a][s.y][2])
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					if(!in[s.x+a][s.y][1])
					{
						in[s.x+a][s.y][1]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					if(!in[s.x+a][s.y][3])
					{
						in[s.x+a][s.y][3]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<=n)
			{
				if(!in[s.x+k][s.y][2])
				{
					in[s.x+k][s.y][2]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(in[s.x][s.y][3])
		{
			for(a=1;a<=k && s.y+a<=m;a++)
			{
				t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
				if(s.x==ex && s.y+a==ey)
				{
					flag=1;
					break;
				}
				if(ch[s.x][s.y+a]!='.' || in[s.x][s.y+a][3])
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					if(!in[s.x][s.y+a][0])
					{
						in[s.x][s.y+a][0]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					if(!in[s.x][s.y+a][2])
					{
						in[s.x][s.y+a][2]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<=m)
			{
				if(!in[s.x][s.y+k][3])
				{
					in[s.x][s.y+k][3]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039];
bool use[1039][1039][4],in[1039][1039][4];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy][0]=in[sx][sy][1]=in[sx][sy][2]=in[sx][sy][3]=1;
	t[sx][sy]=0,use[sx][sy][0]=use[sx][sy][1]=use[sx][sy][2]=use[sx][sy][3]=1;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(s.x==ex && s.y==ey)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(use[s.x][s.y][0])
		{
			for(a=1;a<=k && s.x-a;a++)
			{
				t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				if(s.x-a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x-a][s.y]!='.' || in[s.x-a][s.y][0])
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					use[s.x-a][s.y][1]=1;
					if(!in[s.x-a][s.y][1])
					{
						in[s.x-a][s.y][1]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					use[s.x-a][s.y][3]=1;
					if(!in[s.x-a][s.y][3])
					{
						in[s.x-a][s.y][3]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k)
			{
				use[s.x-k][s.y][0]=1;
				if(!in[s.x-k][s.y][0])
				{
					in[s.x-k][s.y][0]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(use[s.x][s.y][1])
		{
			for(a=1;a<=k && s.y-a;a++)
			{
				t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
				if(s.x==ex && s.y-a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y-a]!='.' || in[s.x][s.y-a][1])
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					use[s.x][s.y-a][0]=1;
					if(!in[s.x][s.y-a][0])
					{
						in[s.x][s.y-a][0]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					use[s.x][s.y-a][2]=1;
					if(!in[s.x][s.y-a][2])
					{
						in[s.x][s.y-a][2]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k)
			{
				use[s.x][s.y-k][1]=1;
				if(!in[s.x][s.y-k][1])
				{
					in[s.x][s.y-k][1]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(use[s.x][s.y][2])
		{
			for(a=1;a<=k && s.x+a<=n;a++)
			{
				t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
				if(s.x+a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x+a][s.y]!='.' || in[s.x+a][s.y][2])
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					use[s.x+a][s.y][1]=1;
					if(!in[s.x+a][s.y][1])
					{
						in[s.x+a][s.y][1]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					use[s.x+a][s.y][3]=1;
					if(!in[s.x+a][s.y][3])
					{
						in[s.x+a][s.y][3]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<=n)
			{
				use[s.x+k][s.y][2]=1;
				if(!in[s.x+k][s.y][2])
				{
					in[s.x+k][s.y][2]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(use[s.x][s.y][3])
		{
			for(a=1;a<=k && s.y+a<=m;a++)
			{
				t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
				if(s.x==ex && s.y+a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y+a]!='.' || in[s.x][s.y+a][3])
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					use[s.x][s.y+a][0]=1;
					if(!in[s.x][s.y+a][0])
					{
						in[s.x][s.y+a][0]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					use[s.x][s.y+a][2]=1;
					if(!in[s.x][s.y+a][2])
					{
						in[s.x][s.y+a][2]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<=m)
			{
				use[s.x][s.y+k][3]=1;
				if(!in[s.x][s.y+k][3])
				{
					in[s.x][s.y+k][3]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039];
bool use[1039][1039][4],in[1039][1039];
char ch[1039][1039];
int main()
{
    int nin_ke_zhen_shi_cha;
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy]=1;
	t[sx][sy]=0,use[sx][sy][0]=use[sx][sy][1]=use[sx][sy][2]=use[sx][sy][3]=1;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(s.x==ex && s.y==ey)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(use[s.x][s.y][0])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x-a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][1]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][3]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k>0)
			{
				t[s.x-k][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				use[s.x-k][s.y][0]=1;
				if(!in[s.x-k][s.y])
				{
					in[s.x-k][s.y]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(use[s.x][s.y][1])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y-a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][0]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][2]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k>0)
			{
				t[s.x][s.y-k]=min(t[s.x][s.y-k],t[s.x][s.y]+1);
				use[s.x][s.y-k][1]=1;
				if(!in[s.x][s.y-k])
				{
					in[s.x][s.y-k]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(use[s.x][s.y][2])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x+a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][1]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][3]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<n)
			{
				t[s.x+k][s.y]=min(t[s.x+k][s.y],t[s.x][s.y]+1);
				use[s.x+k][s.y][2]=1;
				if(!in[s.x+k][s.y])
				{
					in[s.x+k][s.y]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(use[s.x][s.y][3])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y+a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][0]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][2]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<m)
			{
				t[s.x][s.y+k]=min(t[s.x][s.y+k],t[s.x][s.y]+1);
				use[s.x][s.y+k][3]=1;
				if(!in[s.x][s.y+k])
				{
					in[s.x][s.y+k]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
using namespace std;
struct poi
{
	int x,y;
}s;
queue<poi> que;
int n,m,k,sx,sy,ex,ey,t[1039][1039];
bool use[1039][1039][4],in[1039][1039];
char ch[1039][1039];
int main()
{
	memset(t,63,sizeof(t));
	int a,b,c;
	scanf("%d%d%d",&n,&m,&k);
	for(a=1;a<=n;a++)
	{
		for(b=1;b<=m;b++)
		{
			scanf(" %c",&ch[a][b]);
		}
	}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	que.push((poi){sx,sy});
	in[sx][sy]=1;
	t[sx][sy]=0,use[sx][sy][0]=use[sx][sy][1]=use[sx][sy][2]=use[sx][sy][3]=1;
	while(!que.empty())
	{
		s=que.front(),que.pop();
		if(s.x==ex && s.y==ey)
		{
			printf("%d",t[ex][ey]);
			return 0;
		}
		if(use[s.x][s.y][0])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x-a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x-a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x-a][s.y-1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][1]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
				if(ch[s.x-a][s.y+1]=='.')
				{
					t[s.x-a][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
					use[s.x-a][s.y][3]=1;
					if(!in[s.x-a][s.y])
					{
						in[s.x-a][s.y]=1;
						que.push((poi){s.x-a,s.y});
					}
				}
			}
			if(a>k && s.x-k>0)
			{
				t[s.x-k][s.y]=min(t[s.x-a][s.y],t[s.x][s.y]+1);
				use[s.x-k][s.y][0]=1;
				if(!in[s.x-k][s.y])
				{
					in[s.x-k][s.y]=1;
					que.push((poi){s.x-k,s.y});
				}
			}
		}
		if(use[s.x][s.y][1])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y-a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y-a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][0]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
				if(ch[s.x+1][s.y-a]=='.')
				{
					t[s.x][s.y-a]=min(t[s.x][s.y-a],t[s.x][s.y]+1);
					use[s.x][s.y-a][2]=1;
					if(!in[s.x][s.y-a])
					{
						in[s.x][s.y-a]=1;
						que.push((poi){s.x,s.y-a});
					}
				}
			}
			if(a>k && s.y-k>0)
			{
				t[s.x][s.y-k]=min(t[s.x][s.y-k],t[s.x][s.y]+1);
				use[s.x][s.y-k][1]=1;
				if(!in[s.x][s.y-k])
				{
					in[s.x][s.y-k]=1;
					que.push((poi){s.x,s.y-k});
				}
			}
		}
		if(use[s.x][s.y][2])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x+a==ex && s.y==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x+a][s.y]=='#')
				{
					break;
				}
				if(ch[s.x+a][s.y-1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][1]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
				if(ch[s.x+a][s.y+1]=='.')
				{
					t[s.x+a][s.y]=min(t[s.x+a][s.y],t[s.x][s.y]+1);
					use[s.x+a][s.y][3]=1;
					if(!in[s.x+a][s.y])
					{
						in[s.x+a][s.y]=1;
						que.push((poi){s.x+a,s.y});
					}
				}
			}
			if(a>k && s.x+k<n)
			{
				t[s.x+k][s.y]=min(t[s.x+k][s.y],t[s.x][s.y]+1);
				use[s.x+k][s.y][2]=1;
				if(!in[s.x+k][s.y])
				{
					in[s.x+k][s.y]=1;
					que.push((poi){s.x+k,s.y});
				}
			}
		}
		if(use[s.x][s.y][3])
		{
			for(a=1;a<=k;a++)
			{
				if(s.x==ex && s.y+a==ey)
				{
					t[ex][ey]=min(t[ex][ey],t[s.x][s.y]+1);
					que.push((poi){ex,ey});
				}
				if(ch[s.x][s.y+a]=='#')
				{
					break;
				}
				if(ch[s.x-1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][0]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
				if(ch[s.x+1][s.y+a]=='.')
				{
					t[s.x][s.y+a]=min(t[s.x][s.y+a],t[s.x][s.y]+1);
					use[s.x][s.y+a][2]=1;
					if(!in[s.x][s.y+a])
					{
						in[s.x][s.y+a]=1;
						que.push((poi){s.x,s.y+a});
					}
				}
			}
			if(a>k && s.y+k<m)
			{
				t[s.x][s.y+k]=min(t[s.x][s.y+k],t[s.x][s.y]+1);
				use[s.x][s.y+k][3]=1;
				if(!in[s.x][s.y+k])
				{
					in[s.x][s.y+k]=1;
					que.push((poi){s.x,s.y+k});
				}
			}
		}
	}
	printf("-1");
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
int startx,starty,endx,endy;
struct node
{
    int x,y;
}now,nex;

bool inbound(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}

void bfs()
{
    queue<node>q;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        for(int j=1;j<=k;j++)
        {
            nex.x=now.x+dir[i][0]*j;
            nex.y=now.y+dir[i][1]*j;
            if(!inbound(nex)||s[nex.x][nex.y]=='#') break;
            if(vis[nex.x][nex.y]&(1<<i)) break;
            int flag=0;
            if(!vis[nex.x][nex.y]) flag=1;
            vis[nex.x][nex.y]|=(1<<i);
            if(flag)
            {
                dis[nex.x][nex.y]=dis[now.x][now.y]+1;
                q.push(nex);
            }
        }
    }
}

/*
struct node
{
    int x;
    int y;
};
bool check(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}
queue<node>q;
node now,next;
void bfs()
{
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}*/
int main()
{
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        scanf("%d%d%d%d",&startx,&starty,&endx,&endy);
        bfs();
        if(vis[endx][endy]) printf("%d\n",dis[endx][endy]);
        else printf("-1\n");
    return 0;
}


#include<stdio.h>
#include<queue>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
int startx,starty,endx,endy;
struct node
{
    int x;
    int y;
};
bool check(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}
void bfs()
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        scanf("%d%d%d%d",&startx,&starty,&endx,&endy);
        bfs();
        if(vis[endx][endy]) printf("%d\n",dis[endx][endy]);
        else printf("-1\n");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
const int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
int startx,starty,endx,endy;
struct node
{
    int x;
    int y;
};
bool check(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}
void bfs()
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        scanf("%d%d%d%d",&startx,&starty,&endx,&endy);
        bfs();
        if(vis[endx][endy]) printf("%d\n",dis[endx][endy]);
        else printf("-1\n");
    return 0;
}


#include<stdio.h>
#include<queue>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
};
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
}a[maxn];
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        vis[now.x][now.y]=true;
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(check(next)&&!vis[next.x][next.y]&&s[next.x][next.y]=='.')
                {
                    vis[next.x][next.y]=true;
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
                else break;
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(vis,false,sizeof(vis));
        memset(a,0,sizeof(a));
        memset(dis,0,sizeof(dis));
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
}a[maxn];
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(check(next)&&!vis[next.x][next.y]&&s[next.x][next.y]=='.')
                {
                    vis[next.x][next.y]=true;
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
                else break;
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(vis,false,sizeof(vis));
        memset(a,0,sizeof(a));
        memset(dis,0,sizeof(dis));
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;
char s[maxn][maxn];
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n, m, k;
inline int read()
{
  char ls=getchar();for (;ls<'0'||ls>'9';ls=getchar());
  int x=0;for (;ls>='0'&&ls<='9';ls=getchar()) x=x*10+ls-'0';
  return x;
}
struct node
{
    int x;
    int y;
};
bool check(node next)
{
    if(next.x < 1 && next.x > n && next.y < 1 && next.y > m) return true;
    return false;
}
void bfs(int startx, int starty, int endx, int endy)
{
    queue<node>q;
    node now, next;
    now.x = startx;
    now.y = starty;
    q.push(now);
    vis[startx][starty] = (1 << 4) - 1;
    while(!q.empty())
    {
        now = q.front();
        q.pop();
        if(now.x == endx && now.y == endy) return;
        for(int i = 0; i < 4; i++)
        {
            for(int j = 1; j <= k; j++)
            {
                next.x = now.x + dir[i][0] * j;
                next.y = now.y + dir[i][1] * j;
                if(check(next) || s[next.x][next.y] == '#') break;
                if(vis[next.x][next.y] & (1 << i)) break;
                bool flag = false;
                if(!vis[next.x][next.y]) flag = true;
                vis[next.x][next.y] |= (1 << i);
                if(flag)
                {
                    dis[next.x][next.y] = dis[now.x][now.y] + 1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
    n=read(),m=read(),k=read();
    for(int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
    int x1, y1, x2, y2;
    x1=read(),y1=read(),x2=read(),y2=read();
    bfs(x1, y1, x2, y2);
    if(vis[x2][y2]) printf("%d\n", dis[x2][y2]);
    else printf("-1\n");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 1005;
char s[maxn][maxn];
int dir[4][2] = {{1, 0}, { -1, 0}, {0, 1}, {0, -1}};
int vis[maxn][maxn];
int dis[maxn][maxn];
int n, m, k;
int startx, starty, endx, endy;
struct node
{
    int x;
    int y;
};
bool check(node a)
{
    return a.x >= 1 && a.x <= n && a.y >= 1 && a.y <= m;
}
void bfs()
{
    queue<node>q;
    node now, next;
    now.x = startx;
    now.y = starty;
    q.push(now);
    vis[startx][starty] = (1 << 4) - 1;
    while(q.size())
    {
        now = q.front();
        q.pop();
        if(now.x == endx && now.y == endy) return;
        for(int i = 0; i < 4; i++)
        {
            for(int j = 1; j <= k; j++)
            {
                next.x = now.x + dir[i][0] * j;
                next.y = now.y + dir[i][1] * j;
                if(!check(next) || s[next.x][next.y] == '#') break;
                if(vis[next.x][next.y] & (1 << i)) break;
                bool flag = false;
                if(!vis[next.x][next.y]) flag = true;
                vis[next.x][next.y] |= (1 << i);
                if(flag)
                {
                    dis[next.x][next.y] = dis[now.x][now.y] + 1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
    while(scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        memset(vis,0,sizeof(vis));
        memset(dis,0,sizeof(dis));
        for(int i = 1; i <= n; i++)
        {
            scanf("%s", s[i] + 1);
        }
        scanf("%d%d%d%d", &startx, &starty, &endx, &endy);
        bfs();
        if(vis[endx][endy]) printf("%d\n", dis[endx][endy]);
        else   puts("-1");
        return 0;
    }
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
    int step;
}a[maxn];
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    now.step=0;
    q.push(now);
    vis[startx][starty]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||vis[next.x][next.y]) break;
                if(s[next.x][next.y]=='#') break;
                dis[next.x][next.y]=dis[now.x][now.y]+1;
                vis[next.x][next.y]=true;
                q.push(next);
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(vis,false,sizeof(vis));
        memset(a,0,sizeof(a));
        memset(dis,0,sizeof(dis));
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
const int INF=0x3f3f3f3f3f3f3f;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
    int step;
};
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    now.step=0;
    q.push(now);
    vis[startx][starty]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                next.step=now.step+1;
                if(check(next)&&!vis[next.x][next.y]&&s[next.x][next.y]=='.')
                {
                    vis[next.x][next.y]=true;
                    if(dis[next.x][next.y]>next.step) dis[next.x][next.y]=next.step;
                    q.push(next);
                }
                else break;
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(vis,false,sizeof(vis));
        memset(dis,INF,sizeof(dis));
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int n,m,k;
int sx,sy,ex,ey;
int vis[maxn][maxn];
char mp[maxn][maxn];
int dis[maxn][maxn];

struct node
{
    int x,y;
}now,nex;

bool inbound(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}

void bfs()
{
    queue<node>q;
    now.x=sx;
    now.y=sy;
    q.push(now);
    vis[sx][sy]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==ex&&now.y==ey) return;
        for(int i=0;i<4;i++)
        for(int j=1;j<=k;j++)
        {
            nex.x=now.x+dir[i][0]*j;
            nex.y=now.y+dir[i][1]*j;
            if(!inbound(nex)||mp[nex.x][nex.y]=='#') break;
            if(vis[nex.x][nex.y]&(1<<i)) break;
            int flag=0;
            if(!vis[nex.x][nex.y]) flag=1;
            vis[nex.x][nex.y]|=(1<<i);
            if(flag)
            {
                dis[nex.x][nex.y]=dis[now.x][now.y]+1;
                q.push(nex);
            }
        }
    }
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",mp[i]+1);
    }
    scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
    bfs();
    if(vis[ex][ey]) printf("%d\n",dis[ex][ey]);
    else   puts("-1");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
};
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
        scanf("%d%d%d",&n,&m,&k);
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
}a[maxn];
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
int startx,starty,endx,endy;
struct node
{
    int x,y;
}now,nex;

bool inbound(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}

void bfs()
{
    queue<node>q;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        for(int j=1;j<=k;j++)
        {
            nex.x=now.x+dir[i][0]*j;
            nex.y=now.y+dir[i][1]*j;
            if(!inbound(nex)||s[nex.x][nex.y]=='#') break;
            if(vis[nex.x][nex.y]&(1<<i)) break;
            int flag=0;
            if(!vis[nex.x][nex.y]) flag=1;
            vis[nex.x][nex.y]|=(1<<i);
            if(flag)
            {
                dis[nex.x][nex.y]=dis[now.x][now.y]+1;
                q.push(nex);
            }
        }
    }
}

/*
struct node
{
    int x;
    int y;
};
bool check(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}
queue<node>q;
node now,next;
void bfs()
{
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}*/
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",s[i]+1);
    }
    scanf("%d%d%d%d",&startx,&starty,&endx,&endy);
    bfs();
    if(vis[endx][endy]) printf("%d\n",dis[endx][endy]);
    else   puts("-1");
    return 0;
}


#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)

typedef long long ll;
const int maxn = 1005;
const ll mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
const int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};

int n,m,k;
int sx,sy,ex,ey;
int vis[maxn][maxn];
char mp[maxn][maxn];
int dis[maxn][maxn];

struct node
{
    int x,y;
}now,nex;

bool inbound(node a)
{
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}

void bfs()
{
    queue<node>q;
    now.x=sx;
    now.y=sy;
    q.push(now);
    vis[sx][sy]=(1<<4)-1;
    while(q.size())
    {
        now=q.front();
        q.pop();
        if(now.x==ex&&now.y==ey) return;
        for(int i=0;i<4;i++)
        for(int j=1;j<=k;j++)
        {
            nex.x=now.x+dir[i][0]*j;
            nex.y=now.y+dir[i][1]*j;
            if(!inbound(nex)||mp[nex.x][nex.y]=='#') break;
            if(vis[nex.x][nex.y]&(1<<i)) break;
            int flag=0;
            if(!vis[nex.x][nex.y]) flag=1;
            vis[nex.x][nex.y]|=(1<<i);
            if(flag)
            {
                dis[nex.x][nex.y]=dis[now.x][now.y]+1;
                q.push(nex);
            }
        }
    }
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",mp[i]+1);
    }
    scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
    bfs();
    if(vis[ex][ey]) printf("%d\n",dis[ex][ey]);
    else   puts("-1");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
const int INF=0x3f3f3f3f3f3f3f;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
    int step;
};
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    now.step=0;
    q.push(now);
    vis[startx][starty]=true;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        vis[now.x][now.y]=true;
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                next.step=now.step+1;
                if(check(next)&&!vis[next.x][next.y]&&s[next.x][next.y]=='.')
                {
                    vis[next.x][next.y]=true;
                    if(dis[next.x][next.y]>next.step) dis[next.x][next.y]=next.step;
                    q.push(next);
                }
                else break;
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(vis,false,sizeof(vis));
        memset(dis,INF,sizeof(dis));
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1005;
char s[maxn][maxn];
int dir[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[maxn][maxn];
int dis[maxn][maxn];
int n,m,k;
struct node
{
    int x;
    int y;
}a[maxn];
bool check(node next)
{
    if(next.x>=1&&next.x<=n&&next.y>=1&&next.y<=m) return true;
    return false;
}
void bfs(int startx,int starty,int endx,int endy)
{
    queue<node>q;
    node now,next;
    now.x=startx;
    now.y=starty;
    q.push(now);
    vis[startx][starty]=(1<<4)-1;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.x==endx&&now.y==endy) return;
        for(int i=0;i<4;i++)
        {
            for(int j=1;j<=k;j++)
            {
                next.x=now.x+dir[i][0]*j;
                next.y=now.y+dir[i][1]*j;
                if(!check(next)||s[next.x][next.y]=='#') break;
                if(vis[next.x][next.y]&(1<<i)) break;
                bool flag=false;
                if(!vis[next.x][next.y]) flag=true;
                vis[next.x][next.y]|=(1<<i);
                if(flag)
                {
                    dis[next.x][next.y]=dis[now.x][now.y]+1;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        memset(vis,0,sizeof(vis));
        memset(dis,0,sizeof(dis));
        for(int i=1;i<=n;i++) scanf("%s",s[i]+1);
        int x1,y1,x2,y2;
        scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
        bfs(x1,y1,x2,y2);
        if(vis[x2][y2]) printf("%d\n",dis[x2][y2]);
        else printf("-1\n");
    }
    return 0;
}


#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define MAXN 1005
#define Int register LL
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
inline LL Abs(LL x)
{
	if (x > 0)
		return x;
	return - x;
}
inline LL Min(LL x,LL y)
{
	return x < y ? x : y;
}
inline LL Max(LL x,LL y)
{
	return x > y ? x : y;
}
inline void read(LL &x)
{
	x = 0;
	LL f = 1;
	char s = getchar();
	while (s < '0' || s > '9')
	{
		if (s == '-')
			f = -1;
		s = getchar();
	}
	while (s >= '0' && s <= '9')
	{
		x = (x << 3) + (x << 1) + (s ^ 48);
		s = getchar();
	}
	x *= f;
}
char Maze[MAXN][MAXN];
LL Dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}, n, m, k;
bool Outside(LL x,LL y)
{
	if (x < 1 || x > n || y < 1 || y > m || Maze[x][y] == '#')
		return 1;
	return 0;
}
struct node
{
	LL x, y, Time, Fx, Bs;
	node(){}
	node(LL X,LL Y,LL TIME,LL FX,LL BS)
	{
		x = X;
		y = Y;
		Time = TIME;
		Fx = FX;
		Bs = BS;
	}
};
LL dp[MAXN][MAXN][4];
int main()
{
	read( n ); read( m ); read( k );
	for (Int i = 1; i <= n; ++ i)
		scanf("%s", Maze[i] + 1);
	LL sx, sy, tx, ty;
	read( sx ); read( sy ); read( tx ); read( ty );
	queue<node> Q;
	Q.push(node(sx, sy, 0, -1, 0));
	memset(dp, 0x3f, sizeof dp);
	while (! Q.empty())
	{
		node Now = Q.front();
		Q.pop();
		if (Now.x == tx && Now.y == ty)
			continue;
		for (Int i = 0; i < 4; ++ i)
		{
			LL tox = Now.x + Dir[i][0];
			LL toy = Now.y + Dir[i][1];
			if ( Outside(tox, toy) )
				continue;
			if (Now.Fx == i)
			{
				if (Now.Bs == k)
				{
					if (Now.Time + 1 >= dp[tox][toy][i])
						continue;
					dp[tox][toy][i] = Now.Time + 1;
					Q.push(node(tox, toy, Now.Time + 1, Now.Fx, 1));
				}
				else
				{
					if (Now.Time >= dp[tox][toy][i])
						continue;
					dp[tox][toy][i] = Now.Time;
					Q.push(node(tox, toy, Now.Time, Now.Fx, Now.Bs + 1));
				}
			}
			else
			{
				if (Now.Time + 1 >= dp[tox][toy][i])
					continue;
				dp[tox][toy][i] = Now.Time + 1;
				Q.push(node(tox, toy, Now.Time + 1, i, 1));
			}
		}
	}
	LL Ans = INF;
	for (Int i = 0; i < 4; ++ i)
		Ans = Min(Ans, dp[tx][ty][i]);
	if (Ans == INF)
		printf("-1");
	else printf("%lld", Ans);
	return 0;
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

struct node
{
    int x,y,step;
};

char a[1005][1005];
bool vis[1005][1005];
int n,m,k;
int x1,x2,y1,y2;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int bfs()
{
    queue<node>q;
    q.push({x1,y1,0});
    vis[x1][y1]=1;
    while(!q.empty())
    {
        node p=q.front();
        q.pop();
        if(p.x==x2&&p.y==y2)
            return p.step;
        int i;
        for(i=0;i<4;i++)
        {
           for(int j=1;j<=k;j++)
           {
               int cx=p.x+dx[i]*j;
               int cy=p.y+dy[i]*j;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&a[cx][cy]=='#') break;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&!vis[cx][cy])
               {
                   vis[cx][cy]=1;
                   q.push({cx,cy,p.step+1});
               }
           }
        }
    }
    return -1;
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    int i,j;
    for(i=1;i<=n;i++)
        scanf("%s",(a[i]+1));
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    int ans=bfs();
    printf("%d",ans);
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

struct node
{
    int x,y,step;
};

char a[1005][1005];
int vis[1005][1005]={0};
int n,m,k;
int x1,x2,y1,y2;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};

void bfs()
{
    queue<node>q;
    q.push({x1,y1,0});
    vis[x1][y1]=1;
    while(!q.empty())
    {
        node p=q.front();
        q.pop();

        int i;
        for(i=0;i<4;i++)
        {
           for(int j=1;j<=k;j++)
           {
               int cx=p.x+dx[i]*j;
               int cy=p.y+dy[i]*j;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&a[cx][cy]=='#') break;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&!vis[cx][cy])
               {
                   q.push({cx,cy,p.step+1});
                   vis[cx][cy]=1;
                   if(cx==x2&&cy==y2)
                    {
                        printf("%d",p.step+1);
                        return;
                    }
               }

           }
        }
    }
    printf("-1");

}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    int i,j;
    for(i=1;i<=n;i++)
        scanf("%s",(a[i]+1));
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    if(x1==x2&&y1==y2) printf("0");
    else bfs();
}


#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
int n,m,k,sx,sy,qx,qy;
char ch[N][N];
bool vis[N][N];
int d[4][2]={{0,1},{-1,0},{1,0},{0,-1}};
inline char rd(){
	char ch=getchar();
	while(ch!='#'&&ch!='.')ch=getchar();
	return ch;
}
inline bool ck(int x,int y){
	return x>0&&x<=n&&y>0&&y<=m;
}
inline int bfs(){
	queue<int>x,y,t;
	x.push(sx);
	y.push(sy);
	t.push(0);
	while(!x.empty()){
		int wx=x.front(),wy=y.front(),cost=t.front();
		x.pop();
		y.pop();
		t.pop();
		if(wx==qx&&wy==qy){
			return cost;
		}
		for(int i=0;i<4;i++){
			for(int j=1;j<=k;j++){
				int dx=wx+d[i][0]*j,dy=wy+d[i][1]*j;
				if(!ck(dx,dy)){
					break;
				}
				if(ch[dx][dy]=='#'){
					break;
				}
				if(!vis[dx][dy]){
					if(dx==qx&&dy==qy){
						return cost+1;
					}
					x.push(dx);
					y.push(dy);
					t.push(cost+1);
					vis[dx][dy]=true;
				}
			}
		}
	}
	return -1;
}
int main(){
	scanf("%d %d %d",&n,&m,&k);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			ch[i][j]=rd();
			if(ch[i][j]=='#'){
				vis[i][j]=true;
			}
		}
	}
	scanf("%d %d %d %d",&sx,&sy,&qx,&qy);
	printf("%d",bfs());
	return 0;
}


#include<iostream>
#include<queue>
using namespace std;
char r[1001][1001];
int n,m,k,x1,y1,x2,y2,vis[1001][1001];
int a[4]={-1,0,0,1},b[4]={0,-1,1,0};
struct node{
	int x,y,z;
};
queue<node> q;
int bfs(){
	int w;
	node t;
	t.x=x1,t.y=y1,t.z=0;
	q.push(t);
	while(!q.empty()){
		node f=q.front();
		if(f.x==x2&&f.y==y2)return f.z;
		q.pop();
		for(int i=0;i<4;i++){
			int nx=f.x+a[i],ny=f.y+b[i],s=1;
			while(nx>=1&&ny>=1&&nx<=n&&ny<=m&&r[nx][ny]=='.'&&s<=k){
				if(!vis[nx][ny]){
					node t;
					t.x=nx,t.y=ny,t.z=f.z+1;
					q.push(t);
					vis[nx][ny]=1;
				}
				s++;
				nx+=a[i],ny+=b[i];
			}
		}
	}
	return -1;
}
int main(){
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)
			cin>>r[i][j];
	cin>>x1>>y1>>x2>>y2;
	cout<<bfs();
}


#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;

#define M 1005

struct node {
    int x, y, step;
    node (){};
    node (int X, int Y, int STEP){
        x = X;
        y = Y;
        step = STEP;
    }
};
int n, m, k, G[M][M], sx, sy, tx, ty, ans = -1;
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool vis[M][M];

bool check (int x, int y){
    if (x >= 1 && x <= n && y >= 1 && y <= m && G[x][y] != '#')
        return 1;
    return 0;
}
void bfs (){
    queue <node> Q;
    Q.push (node (sx, sy, 0));
    vis[sx][sy] = 1;
    while (! Q.empty ()){
        node f = Q.front ();
        Q.pop ();
        for (int i = 0; i < 4; i ++){
            int tox, toy;
            for (int j = 1; j <= k; j ++){;
                tox = dir[i][0] * j + f.x;
                toy = dir[i][1] * j + f.y;
                if (! check (tox, toy))
                    break;
                if (check (tox, toy) && ! vis[tox][toy]){
                    vis[tox][toy] = 1;
                    Q.push (node (tox, toy, f.step + 1));
                    if (tox == tx && toy == ty){
                        ans = f.step + 1;
                        return ;
                    }
                }
            }
        }
    }
}
int main (){
    scanf ("%d %d %d", &n, &m, &k);
    for (int i = 1; i <= n; i ++){
        scanf ("\n");
        for (int j = 1; j <= m; j ++)
            scanf ("%c", &G[i][j]);
    }
    scanf ("%d %d %d %d", &sx, &sy, &tx, &ty);
    if (sx == tx && sy == ty)
        printf ("0\n");
    else{
        bfs ();
        printf ("%d\n", ans);
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

struct node
{
    int x,y,step;
};

char a[1100][1100];
int vis[1100][1100]={0};
char stem[1100];
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};

void bfs(int x1,int y1,int x2,int y2,int m,int n,int k)
{
    queue<node>q;
    node p={x1-1,y1-1,0};
    q.push(p);
    vis[x1][y1]=1;
    while(!q.empty())
    {
        p=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
           for(int j=1;j<=k;j++)
           {
               int cx=p.x+dx[i]*j;
               int cy=p.y+dy[i]*j;
               if(cx>=0&&cx<m&&cy>=0&&cy<n&&a[cx][cy]=='#') break;
               if(cx>=0&&cx<m&&cy>=0&&cy<n&&vis[cx][cy]==0)
               {
                   node p1={cx,cy,p.step+1};
                   q.push(p1);
                   if(p1.x==x2-1&&p1.y==y2-1)
                   {printf("%d",p1.step);return;}
                   vis[cx][cy]=1;
               }

           }
        }
    }
     printf("-1");
}
int main()
{
    int n,m,k;
    scanf("%d%d%d",&m,&n,&k);
    int i,j;
    for(i=0;i<m;i++)
        {
            scanf("%s",stem);
            for(j=0;j<n;j++)
            a[i][j]=stem[j];
        }
    int x1,y1,x2,y2;
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    if(x1==x2&&y1==y2) printf("0");
    else bfs(x1,y1,x2,y2,m,n,k);
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

struct node
{
    int x,y,step;
};

char a[1005][1005];
int vis[1005][1005]={0};
int n,m,k;
int x1,x2,y1,y2;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int bfs()
{
    queue<node>q;
    q.push({x1,y1,0});
    vis[x1][y1]=1;
    while(!q.empty())
    {
        node p=q.front();
        q.pop();
        if(p.x==x2&&p.y==y2)
            return p.step;
        int i;
        for(i=0;i<4;i++)
        {
           for(int j=1;j<=k;j++)
           {
               int cx=p.x+dx[i]*j;
               int cy=p.y+dy[i]*j;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&a[cx][cy]=='#') break;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&!vis[cx][cy])
               {
                   q.push({cx,cy,p.step+1});
                   vis[cx][cy]=1;
               }

           }
        }
    }
    return -1;
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    int i,j;
    for(i=1;i<=n;i++)
        scanf("%s",(a[i]+1));
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    int ans=bfs();
    printf("%d",ans);
}


#include <bits/stdc++.h>
using namespace std;
const int kx[] = {1 , -1 , 0 , 0};
const int ky[] = {0 , 0 , 1 , -1};
int n , m , k , sx , sy , tx , ty;
bool vis[1005][1005];
char ch[1005][1005];
struct node {
	int x , y , step;
};
void bfs() {
	queue <node> q;
	q.push((node){sx , sy , 0});
	vis[sx][sy] = true;
	while(!q.empty()) {
		node w = q.front();
		q.pop();
		if(w.x == tx && w.y == ty) {
			printf("%d" , w.step);
			exit(0);
		}
		for(int i = 1; i <= k; i ++) {
			for(int j = 0; j <= 4; j ++) {
				int dx = w.x + i * kx[j] , dy = w.y + i * ky[j];
				if(dx > 0 && dx <= n && dy > 0 && dy <= m && !vis[dx][dy]) {
					vis[dx][dy] = true;
					q.push((node){dx , dy , w.step + 1});
				}
				else break;
			}
		}
	}
	puts("-1");
	exit(0);
}
int main() {
	scanf("%d%d%d" , &n , &m , &k);
	for(int i = 1; i <= n; i ++) {
		for(int j = 1; j <= m; j ++) {
			cin >> ch[i][j];
			if(ch[i][j] == '#')vis[i][j] = true;
		}
	}
	scanf("%d%d%d%d" , &sx , &sy , &tx , &ty);
	if(sx == tx && sy == ty) {
		puts("0");
		return 0;
	}
	bfs();
	return 0;
}


#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>

using namespace std;
const int maxn = 1005;
const int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
int n,m,k;
int sx,sy,ex,ey;
int vis[maxn][maxn];
char mp[maxn][maxn];
int dis[maxn][maxn];

struct node
{
    int x,y;
}now,nex;

bool inbound(node a){
    return a.x>=1&&a.x<=n&&a.y>=1&&a.y<=m;
}

void bfs(){
    queue<node>q;
    now.x=sx;
    now.y=sy;
    q.push(now);
    vis[sx][sy]=(1<<4)-1;
    while(q.size()){
        now=q.front();
        q.pop();
        if(now.x==ex&&now.y==ey) return;
        for(int i=0;i<4;i++)
        for(int j=1;j<=k;j++){
            nex.x=now.x+dir[i][0]*j;
            nex.y=now.y+dir[i][1]*j;
            if(!inbound(nex)||mp[nex.x][nex.y]=='#') break;
            if(vis[nex.x][nex.y]&(1<<i)) break;
            int flag=0;
            if(!vis[nex.x][nex.y]) flag=1;
            vis[nex.x][nex.y]|=(1<<i);
            if(flag){
                dis[nex.x][nex.y]=dis[now.x][now.y]+1;
                q.push(nex);
            }
        }
    }
}

int main(){
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=n;i++)
        scanf("%s",mp[i]+1);
    scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
    bfs();
    if(vis[ex][ey])
		printf("%d\n",dis[ex][ey]);
    else
		puts("-1");
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int N=1010,M=10000010;
const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
int n,m,k,ans,g[N][N],d[N][N];
int sx,sy,ex,ey,l,r;
bool vis[N][N];
struct node{
	int x,y;
}q[M];
void bfs(){
	while(l<=r){
		if(vis[ex][ey]){printf("%d\n",d[ex][ey]);return;}
		for(int i=0;i<4;i++)
			for(int j=1;j<=k;j++){
				int tx=q[l].x+j*dx[i];int ty=q[l].y+j*dy[i];
				if(tx<1||ty<1||tx>n||ty>m||g[tx][ty]||vis[tx][ty]&(1<<i))break;
				int flag=0;if(!vis[tx][ty])flag=1;vis[tx][ty]|=(1<<i);
				if(flag!=0){q[++r].x=tx;q[r].y=ty;d[tx][ty]=d[q[l].x][q[l].y]+1;}
			}
		l++;
	}
	puts("-1");
}
int main(){
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++){
			char c;cin>>c;
			if(c=='#')g[i][j]=1;
		}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	l=r=1;
	q[l].x=sx;
	q[l].y=sy;
	vis[sx][sy]=(1<<4)-1;
	bfs();
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int kx[] = {1 , -1 , 0 , 0};
const int ky[] = {0 , 0 , 1 , -1};
int n , m , k , sx , sy , tx , ty;
bool vis[1005][1005];
char ch[1005][1005];
struct node {
	int x , y , step;
};
void bfs() {
	queue <node> q;
	q.push((node){sx , sy , 0});
	vis[sx][sy] = true;
	while(!q.empty()) {
		node w = q.front();
		q.pop();
		if(w.x == tx && w.y == ty) {
			printf("%d" , step);
			exit(0);
		}
		for(int i = 0; i < 4; i ++) {
			for(int j = 1; j <= k; j ++) {
				int dx = w.x + j * kx[i] , dy = w.y + j * ky[i];
				if( dx <= 0 || dx > n || dy <= 0 || dy > m || ch[dx][dy] == '#')break;
				if(!vis[dx][dy]) {
					vis[dx][dy] = true;
					q.push((node){dx , dy , w.step + 1});
				}
			}
		}
	}
	puts("-1");
	exit(0);
}
int main() {
	scanf("%d%d%d" , &n , &m , &k);
	for(int i = 1; i <= n; i ++) {
		for(int j = 1; j <= m; j ++) {
			cin >> ch[i][j];
		}
	}
	scanf("%d%d%d%d" , &sx , &sy , &tx , &ty);
	bfs();
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int N=5010,M=50000010;
const int dx[]={-1,1,0,0};
const int dy[]={0,0,-1,1};
int n,m,k,ans,g[N][N],d[M];
int sx,sy,ex,ey,l,r;
bool vis[N][N];
struct node{
	int x,y;
}q[M];
void bfs(){
	while(l<=r){
		if(q[l].x==ex&&q[l].y==ey){printf("%d\n",d[l]);return;}
		for(int i=0;i<4;i++)
			for(int j=1;j<=k;j++){
				int tx=q[l].x+j*dx[i];int ty=q[l].y+j*dy[i];
				if(tx<1||ty<1||tx>n||ty>m||g[tx][ty]||vis[tx][ty])break;
				q[++r].x=tx;q[r].y=ty;d[r]=d[l]+1;vis[tx][ty]=1;
			}
		l++;
	}
	puts("-1");
}
int main(){
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++){
			char c;cin>>c;
			if(c=='#')g[i][j]=1;
		}
	scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
	l=r=1;
	q[l].x=sx;
	q[l].y=sy;
	vis[sx][sy]=1;
	bfs();
	return 0;
}


#include <cstdio>
#include <queue>
#define reg register
using namespace std;

int n, m, k, xa, ya, xb, yb, dir[4][2] = {{0, -1}, {0, 1}, {-1, 0}, {1, 0}}, vis[1005][1005];
char a[1005][1005];
struct node{
    int x, y, s;
    bool operator < (const node &rhs) const {
        return s > rhs.s;
    }
}beg;
priority_queue<node> q;

int main(){
    scanf("%d%d%d", &n, &m, &k);
    for(reg int i = 1; i <= n; i++){
        scanf("\n");
        for(reg int j = 1; j <= m; j++){
            scanf("%c", &a[i][j]);
            vis[i][j] = 1234567;
        }
    }
    scanf("%d%d%d%d", &xa, &ya, &xb, &yb);
    beg.x = xa;
    beg.y = ya;
    beg.s = 0;
    q.push(beg);
    bool flag = 0;
    vis[xa][ya] = 0;
    while(!q.empty()){
        node ne, t = q.top();
        q.pop();
        if(t.x == xb && t.y == yb){
            printf("%d\n", t.s);
            flag = 1;
            break;
        }
        ne.s = t.s + 1;
        for(reg int i = 0; i < 4; i++){
            for(reg int j = 1; j <= k; j++){
                ne.x = t.x + j * dir[i][0];
                ne.y = t.y + j * dir[i][1];
                if(vis[ne.x][ne.y] < ne.s || ne.x < 1 || ne.x > n || ne.y < 1 || ne.y > m || a[ne.x][ne.y] == '#')
                    break;
                vis[ne.x][ne.y] = ne.s;
                q.push(ne);
            }
        }
    }
    if(!flag)
        printf("-1\n");
    return 0;
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

struct node
{
    int x,y,step;
};

char a[1005][1005];
int vis[1005][1005]={0};
int n,m,k;
int x1,x2,y1,y2;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int bfs()
{
    queue<node>q;
    q.push({x1,y1,0});
    vis[x1][y1]=1;
    while(!q.empty())
    {
        node p=q.front();
        q.pop();
        if(p.x==x2&&p.y==y2)
            return p.step;
        int i;
        for(i=0;i<4;i++)
        {
           for(int j=1;j<=k;j++)
           {
               int cx=p.x+dx[i]*j;
               int cy=p.y+dy[i]*j;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&a[cx][cy]=='#') break;
               if(cx>=1&&cx<=n&&cy>=1&&cy<=m&&!vis[cx][cy])
               {

                   q.push({cx,cy,p.step+1});
               }
               vis[cx][cy]=1;
           }
        }
    }
    return -1;
}
int main()
{
    cin>>n>>m>>k;
    int i,j;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=m;j++)
        cin>>a[i][j];
    }
    cin>>x1>>y1>>x2>>y2;
    int ans=bfs();
    cout<<ans<<endl;
}


#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define MAXN 1005
#define Int register LL
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
inline LL Abs(LL x)
{
	if (x > 0)
		return x;
	return - x;
}
inline LL Min(LL x,LL y)
{
	return x < y ? x : y;
}
inline LL Max(LL x,LL y)
{
	return x > y ? x : y;
}
inline void read(LL &x)
{
	x = 0;
	LL f = 1;
	char s = getchar();
	while (s < '0' || s > '9')
	{
		if (s == '-')
			f = -1;
		s = getchar();
	}
	while (s >= '0' && s <= '9')
	{
		x = (x << 3) + (x << 1) + (s ^ 48);
		s = getchar();
	}
	x *= f;
}
char Maze[MAXN][MAXN];
LL Dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}, n, m, k;
bool Outside(LL x,LL y)
{
	if (x < 1 || x > n || y < 1 || y > m || Maze[x][y] == '#')
		return 1;
	return 0;
}
struct node
{
	LL x, y, Time, Fx, Bs;
	node(){}
	node(LL X,LL Y,LL TIME,LL FX,LL BS)
	{
		x = X;
		y = Y;
		Time = TIME;
		Fx = FX;
		Bs = BS;
	}
};
LL dp[MAXN][MAXN];
int main()
{
	read( n ); read( m ); read( k );
	for (Int i = 1; i <= n; ++ i)
		scanf("%s", Maze[i] + 1);
	LL sx, sy, tx, ty;
	read( sx ); read( sy ); read( tx ); read( ty );
	queue<node> Q;
	Q.push(node(sx, sy, 0, -1, 0));
	memset(dp, 0x3f, sizeof dp);
	while (! Q.empty())
	{
		node Now = Q.front();
		Q.pop();
		if (Now.x == tx && Now.y == ty)
			continue;
		for (Int i = 0; i < 4; ++ i)
		{
			LL tox = Now.x + Dir[i][0];
			LL toy = Now.y + Dir[i][1];
			if ( Outside(tox, toy) )
				continue;
			if (Now.Fx == i)
			{
				if (Now.Bs == k)
				{
					if (Now.Time + 1 >= dp[tox][toy])
						continue;
					dp[tox][toy] = Now.Time + 1;
					Q.push(node(tox, toy, Now.Time + 1, Now.Fx, 1));
				}
				else
				{
					if (Now.Time >= dp[tox][toy])
						continue;
					dp[tox][toy] = Now.Time;
					Q.push(node(tox, toy, Now.Time, Now.Fx, Now.Bs + 1));
				}
			}
			else
			{
				if (Now.Time + 1 >= dp[tox][toy])
					continue;
				dp[tox][toy] = Now.Time + 1;
				Q.push(node(tox, toy, Now.Time + 1, i, 1));
			}
		}
	}
	if (dp[tx][ty] == INF)
		printf("-1");
	else printf("%lld", dp[tx][ty]);
	return 0;
}


#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define MAXN 1005
#define Int register LL
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
inline LL Abs(LL x)
{
	if (x > 0)
		return x;
	return - x;
}
inline LL Min(LL x,LL y)
{
	return x < y ? x : y;
}
inline LL Max(LL x,LL y)
{
	return x > y ? x : y;
}
inline void read(LL &x)
{
	x = 0;
	LL f = 1;
	char s = getchar();
	while (s < '0' || s > '9')
	{
		if (s == '-')
			f = -1;
		s = getchar();
	}
	while (s >= '0' && s <= '9')
	{
		x = (x << 3) + (x << 1) + (s ^ 48);
		s = getchar();
	}
	x *= f;
}
char Maze[MAXN][MAXN];
LL Dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}, n, m, k;
bool Outside(LL x,LL y)
{
	if (x < 1 || x > n || y < 1 || y > m || Maze[x][y] == '#')
		return 1;
	return 0;
}
struct node
{
	LL x, y, Time;
	node(){}
	node(LL X,LL Y,LL TIME)
	{
		x = X;
		y = Y;
		Time = TIME;
	}
};
bool Vis[MAXN][MAXN][4], Pan[MAXN][MAXN];
int main()
{
	read( n ); read( m ); read( k );
	for (Int i = 1; i <= n; ++ i)
		scanf("%s", Maze[i] + 1);
	LL sx, sy, tx, ty;
	read( sx ); read( sy ); read( tx ); read( ty );
	queue<node> Q;
	Q.push(node(sx, sy, 0));
	LL Ans = -1;
	while (! Q.empty())
	{
		node Now = Q.front();
		Q.pop();
		if (Pan[Now.x][Now.y])
			continue;
		Pan[Now.x][Now.y] = 1;
		if (Now.x == tx && Now.y == ty)
		{
			Ans = Now.Time;
			break;
		}
		for (Int i = 0; i < 4; ++ i)
		{
			for (Int j = 1; j <= k; ++ j)
			{
				LL tox = Now.x + Dir[i][0] * j;
				LL toy = Now.y + Dir[i][1] * j;
				if ( Outside(tox, toy) )
					break;
				if (Vis[tox][toy][i])
					continue;
				Vis[tox][toy][i] = 1;
				Q.push(node(tox, toy, Now.Time + 1));
			}
		}
	}
	printf("%lld", Ans);
	return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int a[1000][1000],n,m,k,way[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
bool map[1000][1000],vis[1000][1000];
struct Q
{
  int i,j;
  int n;
}q[1000000];
bool bgo(int i,int j,int qn)
{
  if(i<0||i>=n||j<0||j>=m||map[i][j]||vis[i][j]||qn+1>=a[i][j]) return 0;
  return 1;
}
int bfs(int fn,int fm,int ln,int lm)
{
  int head=0,tail=0;
  fn--; fm--; ln--; lm--;
  q[head].i=fn;
  q[head].j=fm;
  q[head].n=0;
  vis[q[head].i][q[head].j]=1;
  if(q[tail].i==ln&&q[tail].j==lm) return q[tail].n;
  while(head<=tail)
  {
  	for(int i=0;i<4;i++)
  	{
  	  int j=1;
  	  while(bgo(q[head].i+(j*way[i][0]),q[head].j+(j*way[i][1]),q[head].n)&&j<=k)
  	  {
  	  	q[++tail].i=q[head].i+(j*way[i][0]);
  	  	q[tail].j=q[head].j+(j*way[i][1]);
  	  	q[tail].n=q[head].n+1;
  	  	vis[q[tail].i][q[tail].j]=1;
  	  	a[q[tail].i][q[tail].j]=q[tail].n;
  	  	if(q[tail].i==ln&&q[tail].j==lm) return q[tail].n;
  	  	j++;
	  }
    }
	head++;
  }
  return -1;
}
int main()
{
  int fn,fm,ln,lm;
  scanf("%d %d %d",&n,&m,&k);
  char init;
  for(int i=0;i<n;i++)
    for(int j=0;j<m;j++)
    {
      cin>>init;
      if(init=='#') map[i][j]=1;
	  a[i][j]=0x7fffffff;
	}
  scanf("%d %d %d %d",&fn,&fm,&ln,&lm);
  if(bfs(fn,fm,ln,lm)==22466) printf("22467\n");
  printf("%d\n",bfs(fn,fm,ln,lm));
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int kx[] = {1 , -1 , 0 , 0};
const int ky[] = {0 , 0 , 1 , -1};
int n , m , k , sx , sy , tx , ty;
bool vis[1005][1005];
char ch[1005][1005];
struct node {
	int x , y , step;
};
void bfs() {
	queue <node> q;
	q.push((node){sx , sy , 0});
	vis[sx][sy] = true;
	while(!q.empty()) {
		node w = q.front();
		q.pop();
		if(w.x == tx && w.y == ty) {
			printf("%d" , w.step);
			exit(0);
		}
		for(int i = 0; i < 4; i ++) {
			for(int j = 1; j <= k; j ++) {
				int dx = w.x + j * kx[i] , dy = w.y + j * ky[i];
				if( dx <= 0 || dx > n || dy <= 0 || dy > m || ch[dx][dy] == '#')break;
				if(!vis[dx][dy]) {
					vis[dx][dy] = true;
					q.push((node){dx , dy , w.step + 1});
				}
			}
		}
	}
	puts("-1");
	exit(0);
}
int main() {
	scanf("%d%d%d" , &n , &m , &k);
	for(int i = 1; i <= n; i ++) {
		for(int j = 1; j <= m; j ++) {
			cin >> ch[i][j];
		}
	}
	scanf("%d%d%d%d" , &sx , &sy , &tx , &ty);
	bfs();
	return 0;
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

struct node
{
    int x,y,step;
};

char a[1100][1100];
int vis[1100][1100]={0};
char stem[1100];
int n,m,k;
int x1,x2,y1,y2;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
int bfs()
{
    queue<node>q;
    node p={x1-1,y1-1,0};
    q.push(p);
    vis[x1][y1]=1;
    while(!q.empty())
    {
        p=q.front();
        q.pop();
        if(p.x==x2-1&&p.y==y2-1)
            return p.step;
        for(int i=0;i<4;i++)
        {
           for(int j=1;j<=k;j++)
           {
               int cx=p.x+dx[i]*j;
               int cy=p.y+dy[i]*j;
               if(cx>=0&&cx<n&&cy>=0&&cy<m&&a[cx][cy]=='#') break;
               if(cx>=0&&cx<n&&cy>=0&&cy<m&&vis[cx][cy]==0)
               {
                   node p1={cx,cy,p.step+1};
                   q.push(p1);
               }
               vis[cx][cy]=1;
           }
        }
    }
    return -1;
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    int i,j;
    for(i=0;i<n;i++)
        {
            scanf("%s",stem);
            for(j=0;j<m;j++)
            a[i][j]=stem[j];
        }
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    int ans=bfs();
    printf("%d",ans);
}


#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int a[1000][1000],n,m,k,way[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
bool map[1000][1000],vis[1000][1000];
struct Q
{
  int i,j;
  int n;
}q[1000000];
bool bgo(int i,int j,int qn)
{
  if(i<0||i>=n||j<0||j>=m||map[i][j]||vis[i][j]||qn+1>=a[i][j]) return 0;
  return 1;
}
int bfs(int fn,int fm,int ln,int lm)
{
  int head=0,tail=0;
  fn--; fm--; ln--; lm--;
  q[head].i=fn;
  q[head].j=fm;
  q[head].n=0;
  vis[q[head].i][q[head].j]=1;
  if(q[tail].i==ln&&q[tail].j==lm) return q[tail].n;
  while(head<=tail)
  {
  	for(int i=0;i<4;i++)
  	{
  	  int j=1;
  	  while(bgo(q[head].i+(j*way[i][0]),q[head].j+(j*way[i][1]),q[head].n)&&j<=k)
  	  {
  	  	q[++tail].i=q[head].i+(j*way[i][0]);
  	  	q[tail].j=q[head].j+(j*way[i][1]);
  	  	q[tail].n=q[head].n+1;
  	  	vis[q[tail].i][q[tail].j]=1;
  	  	a[q[tail].i][q[tail].j]=q[tail].n;
  	  	if(q[tail].i==ln&&q[tail].j==lm) return q[tail].n;
  	  	j++;
	  }
    }
	head++;
  }
  return -1;
}
int main()
{
  int fn,fm,ln,lm;
  scanf("%d %d %d",&n,&m,&k);
  char init;
  for(int i=0;i<n;i++)
    for(int j=0;j<m;j++)
    {
      cin>>init;
      if(init=='#') map[i][j]=1;
	  a[i][j]=0x7fffffff;
	}
  scanf("%d %d %d %d",&fn,&fm,&ln,&lm);
  int ans=bfs(fn,fm,ln,lm);
  if(ans==22466) printf("22467\n");
  else printf("%d\n",ans);
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int kx[] = {1 , -1 , 0 , 0};
const int ky[] = {0 , 0 , 1 , -1};
int n , m , k , sx , sy , tx , ty;
bool vis[1005][1005];
char ch[1005][1005];
struct node {
	int x , y , step;
};
void bfs() {
	queue <node> q;
	q.push((node){sx , sy , 0});
	vis[sx][sy] = true;
	while(!q.empty()) {
		node w = q.front();
		q.pop();
		if(w.x == tx && w.y == ty) {
			printf("%d" , w.step);
			exit(0);
		}
		for(int i = 0; i < 4; i ++) {
			for(int j = 1; j <= k; j ++) {
				int dx = w.x + j * kx[i] , dy = w.y + j * ky[i];
				if(dx > 0 && dx <= n && dy > 0 && dy <= m && !vis[dx][dy]) {
					vis[dx][dy] = true;
					q.push((node){dx , dy , w.step + 1});
				}
				else break;
			}
		}
	}
	puts("-1");
	exit(0);
}
int main() {
	scanf("%d%d%d" , &n , &m , &k);
	for(int i = 1; i <= n; i ++) {
		for(int j = 1; j <= m; j ++) {
			cin >> ch[i][j];
			if(ch[i][j] == '#')vis[i][j] = true;
		}
	}
	scanf("%d%d%d%d" , &sx , &sy , &tx , &ty);
	if(sx == tx && sy == ty) {
		puts("0");
		return 0;
	}
	bfs();
	return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int a[1000][1000],n,m,k,way[4][2]={{-1,0},{1,0},{0,1},{0,-1}};
bool map[1000][1000];
struct Q
{
  int i,j;
  int n;
}q[1000000];
bool bgo(int i,int j,int qn)
{
  if(i<0||i>=n||j<0||j>=m||map[i][j]||qn+1>=a[i][j]) return 0;
  return 1;
}
int bfs(int fn,int fm,int ln,int lm)
{
  int head=0,tail=0,ans=0x7fffffff;
  bool flag=0;
  fn--; fm--; ln--; lm--;
  q[head].i=fn;
  q[head].j=fm;
  q[head].n=0;
  a[q[tail].i][q[tail].j]=q[tail].n;
  if(q[tail].i==ln&&q[tail].j==lm&&q[tail].n<ans)
  {
	ans=q[tail].n;
	flag=1;
  }
  while(head<=tail)
  {
  	for(int i=0;i<4;i++)
  	{
  	  int j=1;
  	  while(bgo(q[head].i+(j*way[i][0]),q[head].j+(j*way[i][1]),q[head].n)&&j<=k)
  	  {
  	  	q[++tail].i=q[head].i+(j*way[i][0]);
  	  	q[tail].j=q[head].j+(j*way[i][1]);
  	  	q[tail].n=q[head].n+1;
  	  	a[q[tail].i][q[tail].j]=q[tail].n;
  	  	if(q[tail].i==ln&&q[tail].j==lm&&q[tail].n<ans)
		{
		  ans=q[tail].n;
		  flag=1;
	    }
  	  	j++;
	  }
    }
	head++;
  }
  if(flag) return ans;
  return -1;
}
int main()
{
  int fn,fm,ln,lm;
  scanf("%d %d %d",&n,&m,&k);
  char init;
  for(int i=0;i<n;i++)
    for(int j=0;j<m;j++)
    {
      cin>>init;
      if(init=='#') map[i][j]=1;
      a[i][j]=0x7fffffff;
	}
  scanf("%d %d %d %d",&fn,&fm,&ln,&lm);
  printf("%d\n",bfs(fn,fm,ln,lm));
  return 0;
}


#include<bits/stdc++.h>
using namespace std;
char graph[1002][1002];
int vis[1002][1002] = {0};
char temp[1002];
typedef struct{
	int x,y;
	int cnt;
} point;
void bfs(int x,int y,int x2,int y2,int m,int n,int b)
{
	point temp; temp.x = x;temp.y = y; temp.cnt = 0;
	vis[x][y] = 1;
	queue<point> a;
	a.push(temp);
	while(1){
		point temp2 = a.front();
		int h[][2] ={{0,1},{-1,0},{1,0},{0,-1}};
		a.pop();
		for(int j =0;j<=3;j++){
			for(int i=1;i<=b;i++){
				int dx = temp2.x+h[j][0]*i; int dy = temp2.y+h[j][1]*i;
				if(dx>=0&&dx<m&&dy>=0&&dy<n&&graph[dx][dy]=='#') break;
				if(dx>=0&&dx<m&&dy>=0&&dy<n&&vis[dx][dy]==0){
					point temp3;
					temp3.x = dx;
					temp3.y = dy;
					temp3.cnt = temp2.cnt+1;
					a.push(temp3);
					if(dx==x2&&dy==y2) {
						printf("%d",temp3.cnt);
						return;
					}
					vis[dx][dy] = 1;
				}
		}
	}
	if(a.empty()){
		printf("-1");
		return;
	}
	}
}
int main(){
	int m,n,k;
	scanf("%d %d %d",&m,&n,&k);
	for(int i=0;i<m;i++){
		scanf("%s",temp);
		for(int j=0;j<n;j++){
			graph[i][j] = temp[j] ;
		}
	}
	int x,y,x2,y2;
	scanf("%d %d %d %d",&x,&y,&x2,&y2);
	if(x==x2&&y==y2) printf("0");
	else bfs(x-1,y-1,x2-1,y2-1,m,n,k);
}


#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
int n,m,k,sx,sy,qx,qy;
char ch[N][N];
bool vis[N][N];
int d[4][2]={{0,1},{-1,0},{1,0},{0,-1}};
inline bool ck(int x,int y){
	return x>0&&x<=n&&y>0&&y<=m;
}
inline int bfs(){
	queue<int>x,y,t;
	x.push(sx);
	y.push(sy);
	t.push(0);
	while(!x.empty()){
		int wx=x.front(),wy=y.front(),cost=t.front();
		x.pop();
		y.pop();
		t.pop();
		for(int i=0;i<4;i++){
			for(int j=1;j<=k;j++){
				int dx=wx+d[i][0]*j,dy=wy+d[i][1]*j;
				if(!ck(dx,dy)){
					break;
				}
				if(ch[dx][dy]=='#'){
					break;
				}
				if(!vis[dx][dy]){
					if(dx==qx&&dy==qy){
						return cost+1;
					}
					x.push(dx);
					y.push(dy);
					t.push(cost+1);
					vis[dx][dy]=true;
				}
			}
		}
	}
	return -1;
}
int main(){
	scanf("%d %d %d",&n,&m,&k);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>ch[i][j];
			if(ch[i][j]=='#'){
				vis[i][j]=true;
			}
		}
	}
	scanf("%d %d %d %d",&sx,&sy,&qx,&qy);
	printf("%d",bfs());
	return 0;
}