Go: package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
)

func configure(scanner *bufio.Scanner) {
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1000005), 1000005)
}
func getNextString(scanner *bufio.Scanner) string {
	scanned := scanner.Scan()
	if !scanned {
		panic("scan failed")
	}
	return scanner.Text()
}
func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}
func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}
func getNextFloat64(scanner *bufio.Scanner) float64 {
	i, _ := strconv.ParseFloat(getNextString(scanner), 64)
	return i
}
func main() {
	fp := os.Stdin
	wfp := os.Stdout
	extra := 0
	if os.Getenv("I") == "IronMan" {
		fp, _ = os.Open(os.Getenv("END_GAME"))
		extra = 100
	}
	scanner := bufio.NewScanner(fp)
	configure(scanner)
	writer := bufio.NewWriter(wfp)
	defer func() {
		r := recover()
		if r != nil {
			fmt.Fprintln(writer, r)
		}
		writer.Flush()
	}()
	solve(scanner, writer)
	for i := 0; i < extra; i++ {
		fmt.Fprintln(writer, "-----------------------------------")
		solve(scanner, writer)
	}
}
func solve(scanner *bufio.Scanner, writer *bufio.Writer) {
	dy := [4]int{-1, 0, 0, 1}
	dx := [4]int{0, -1, 1, 0}
	for {
		h := getNextInt(scanner)
		w := getNextInt(scanner)
		if h == 0 {
			break
		}
		grid := makeGrid(h, w)
		a := [2]int{}
		b := [2]int{}
		for i := 0; i < h; i++ {
			s := getNextString(scanner)
			for j := 0; j < w; j++ {
				if s[j] == '#' {
					grid[i][j] = math.MaxInt32
					continue
				}
				if s[j] == 'A' {
					a[0] = i
					a[1] = j
					continue
				}
				if s[j] == 'B' {
					b[0] = i
					b[1] = j
				}
				grid[i][j] = math.MaxInt32 - 1
			}
		}
		q := make([][2]int, 0)
		q = append(q, a)
		for len(q) > 0 {
			p := q[0]
			q = q[1:]
			for i := 0; i < 4; i++ {
				yy := p[0] + dy[i]
				xx := p[1] + dx[i]
				if yy == a[0] && xx == a[1] {
					continue
				}
				if yy < 0 || yy >= h {
					continue
				}
				if xx < 0 || xx >= w {
					continue
				}
				if grid[yy][xx] == math.MaxInt32 {
					continue
				}
				if grid[yy][xx] <= grid[p[0]][p[1]]+1 {
					continue
				}
				grid[yy][xx] = grid[p[0]][p[1]] + 1
				q = append(q, [2]int{yy, xx})
			}
		}
		move := getNextString(scanner)
		i := 0
		m := len(move)
		for {
			if i > 400 {
				fmt.Fprintln(writer, "impossible")
				break
			}
			if grid[b[0]][b[1]] <= i {
				fmt.Fprintln(writer, fmt.Sprintf("%d %d %d", i, b[0], b[1]))
				break
			}
			switch move[i%m] {
			case '8':
				if b[0] > 0 {
					b[0]--
				}
			case '6':
				if b[1]+1 < w {
					b[1]++
				}
			case '4':
				if b[1] > 0 {
					b[1]--
				}
			case '2':
				if b[0]+1 < h {
					b[0]++
				}
			}
			i++
		}
	}
}
func makeGrid(h, w int) [][]int {
	index := make([][]int, h, h)
	data := make([]int, h*w, h*w)
	for i := 0; i < h; i++ {
		index[i] = data[i*w : (i+1)*w]
	}
	return index
}

C++: #include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <fstream>
#include <iomanip>
//#include <utility>
//#include <memory>
//#include <functional>
//#include <deque>
//#include <cctype>
//#include <ctime>
//#include <numeric>
//#include <list>
//#include <iomanip>

//#if __cplusplus >= 201103L
//#include <array>
//#include <tuple>
//#include <initializer_list>
//#include <forward_list>
//
//#define cauto const auto&
//#else

//#endif

using namespace std;


typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;

#define VV(T) vector<vector< T > >

template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
    v.assign(a, vector<T>(b, t));
}

template <class F, class T>
void convert(const F &f, T &t){
    stringstream ss;
    ss << f;
    ss >> t;
}

#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x)  cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#else
#define dump(x) 
#define debug(x) 
#endif
#define LDcout(x,n) fixed<<setprecision(n)<<x

#define MOD 1000000007LL
#define EPS 1e-8
static const int INF=1<<24;
int h,w;
int dd[]={0,1,0,-1,0};
bool check(int a,int b){
	if(0<=a&&a<h&&0<=b&&b<w) return true;
	return false;
}
void bfs(pii p,int x,vector<string> &v,vvint &vv){
	if(vv[p.F][p.S]>=0) return;
	vv[p.F][p.S]=x;
	rep(i,4){
		pii ne=pii(p.F+dd[i],p.S+dd[i+1]);
		if(!check(ne.F,ne.S)||v[ne.F][ne.S]=='#') continue;
		bfs(ne,x+1,v,vv);
	}
}
void mainmain(){
	vector<pii> vec(10);
	vec[2]=pii(1,0);
	vec[4]=pii(0,-1);
	vec[5]=pii(0,0);
	vec[6]=pii(0,1);
	vec[8]=pii(-1,0);
	while(cin>>h>>w,h||w){
		vector<string> v(h);
		rep(i,h) cin>>v[i];
		string s;
		cin>>s;
		vvint vv;
		initvv(vv,h,w,-1);
		pii A,B;
		rep(i,h){
			rep(j,w){
				if(v[i][j]=='A'){
					A=pii(i,j);
					v[i][j]='.';
				}
				if(v[i][j]=='B'){
					B=pii(i,j);
					v[i][j]='.';
				}
			}
		}
		bfs(A,0,v,vv);
		int ans=-1;
		pii pos;
		rep(i,h){
			rep(j,w){
				// printf("%2d ",vv[i][j]);
				if(vv[i][j]==-1) vv[i][j]=INF;
			}
			// cout<<endl;
		}
		rep(i,2*1e6){
			// cout<<i<<" "<<B.F<<" "<<B.S<<endl;
			if(vv[B.F][B.S]<=i){
				ans=i;
				pos=B;
				break;
			}
			int t=s[i%s.size()]-'0';
			pii ne=pii(B.F+vec[t].F,B.S+vec[t].S);
			if(check(ne.F,ne.S)){
				B=ne;
			}
		}
		if(ans==-1){
			cout<<"impossible"<<endl;
		}
		else{
			cout<<ans<<" "<<pos.F<<" "<<pos.S<<endl;
		}
		// return;
	}
}


signed main() {
	// ios_base::sync_with_stdio(false);
  	cout<<fixed<<setprecision(20);
    mainmain();
}

C++: //35
#include<iostream>
#include<algorithm>
#include<string>
#include<queue>
#include<utility>

using namespace std;

char g[20][20];
int h,w;
int t[20][20];

struct S{
  int t,x,y;
};

int main(){
  while(cin>>h>>w,h|w){
    int ax,ay,bx,by;
    for(int y=0;y<h;y++){
      for(int x=0;x<w;x++){
	cin>>g[y][x];
	if(g[y][x]=='A'){
	  ax=x;
	  ay=y;
	}else if(g[y][x]=='B'){
	  bx=x;
	  by=y;
	}
      }
    }
    fill(t[0],t[20],1<<30);
    queue<S> que;
    S is={0,ax,ay};
    que.push(is);
    while(!que.empty()){
      int x=que.front().x;
      int y=que.front().y;
      int ct=que.front().t;
      que.pop();
      if(t[y][x]<=ct)continue;
      t[y][x]=ct;
      for(int i=0;i<4;i++){
	int d[]={0,1,0,-1,0};
	int nx=x+d[i];
	int ny=y+d[i+1];
	if(nx<0||w<=nx||ny<0||h<=ny||t[ny][nx]<=ct+1||g[ny][nx]=='#')continue;
	S ns={ct+1,nx,ny};
	que.push(ns);
      }
    }
    string p;
    cin>>p;
    int e;
    for(e=0;e<10000;e++){
      if(t[by][bx]<=e)break;
      char o=p[e%p.size()];
      int ny=by+(o=='2')-(o=='8');
      int nx=bx+(o=='6')-(o=='4');
      if(0<=ny&&ny<h&&0<=nx&&nx<w){
	by=ny;
	bx=nx;
      }
    }
    if(e<10000){
      cout<<e<<' '<<by<<' '<<bx<<endl;
    }else{
      cout<<"impossible"<<endl;
    }
  }
  return 0;
}