#include <bits/stdc++.h>
using namespace std;

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}

template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}

template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
	return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value!=0>::type
fill_v(U &u,const V... v){u=U(v...);}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value==0>::type
fill_v(U &u,const V... v){
	for(auto &e:u) fill_v<T>(e,v...);
}

template <typename F>
class
#if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard)
  [[nodiscard]]
#endif  // defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard)
FixPoint final : private F
{
public:
  template <typename G>
  explicit constexpr FixPoint(G&& g) noexcept
    : F{std::forward<G>(g)}
  {}

  template <typename... Args>
  constexpr decltype(auto)
  operator()(Args&&... args) const
#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 9
  noexcept(noexcept(F::operator()(std::declval<FixPoint>(), std::declval<Args>()...)))
#endif  // !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 9
  {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};  // class FixPoint


#if defined(__cpp_deduction_guides)
template <typename F>
FixPoint(F&&)
  -> FixPoint<std::decay_t<F>>;
#endif  // defined(__cpp_deduction_guides)


namespace
{
  template <typename F>
#if !defined(__has_cpp_attribute) || !__has_cpp_attribute(nodiscard)
  #  if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 4)
__attribute__((warn_unused_result))
#  elif defined(_MSC_VER) && _MSC_VER >= 1700 && defined(_Check_return_)
_Check_return_
#  endif  // defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#endif  // !defined(__has_cpp_attribute) || !__has_cpp_attribute(nodiscard)
  inline constexpr decltype(auto)
  makeFixPoint(F&& f) noexcept
  {
    return FixPoint<std::decay_t<F>>{std::forward<std::decay_t<F>>(f)};
  }
}  // namespace


int main(void){
	cin.tie(0);
	ios::sync_with_stdio(false);
	int64 H, W;
	cin >> H>> W;
	vector<string> A(H);
	REP(i, H) {
	  cin >> A[i];
	}

	auto dp = make_v<int64>(H, W);
	fill_v<int64>(dp, -INF_LL);
	auto visited = make_v<int>(H, W);

	auto valid = [&](int y, int x) {
	  return 0<=y&&y<H&&0<=x&&x<W;
	};

	auto dfs = makeFixPoint([&](auto &&dfs, int y, int x) -> int64 {
	  if (visited[y][x]) return dp[y][x];
	  if (y == H-1 && x == W-1) {
	    return 0;
	  }
	  visited[y][x] = 1;

	  if (valid(y + 1, x)) chmax(dp[y][x], -dfs(y + 1, x) + (A[y+1][x] == '+' ? 1 : 0));
	  if (valid(y, x + 1)) chmax(dp[y][x], -dfs(y,x + 1) + (A[y][x + 1] == '+' ? 1 : 0));

//	  cout << y << " " << x << ": " << dp[y][x] << endl;
	  return dp[y][x];
	});

	int64  res = dfs(0, 0);
//	cout << res << endl;
	if (res > 0) {
	  cout << "Takahashi" << endl;
	} else if (res < 0) {
	  cout << "Aoki" << endl;
	} else {
	  cout << "Draw" << endl;
	}
}

#include <bits/stdc++.h>
using namespace std;
 
#define MOD 1000000007
#define mxn 1005
#define mxm 105
#define f first
#define s second
#define pb push_back
#define es " "
#define endl '\n'
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define ll long long
#define fastio ios_base::sync_with_stdio(0), cin.tie(0)
#define sz(x) (int)x.size()
#define all(x) x.begin(), x.end()
typedef pair<ll, ll> pii;
typedef pair<pii, int> pip;
 
int n, m, a, b, memo[20][20];

int solve(int i, int j, int x, int y, int cont){
    if(cont==n*m){
        return 1;
    }
    if(j>m){
        return solve(i+1, 1, x, y, cont);
    }
    if(i>n || x+y<=0){
        return 0;
    }
    ll resp=0;
    if(memo[i][j]){
        return solve(i, j+1, x, y, cont);
    }
    if(!memo[i][j+1] && j+1<=m && x){
        memo[i][j]=1;
        memo[i][j+1]=1;
        resp+=solve(i, j+2, x-1, y, cont+2);
        memo[i][j]=0;
        memo[i][j+1]=0;
    }
    if(!memo[i+1][j] && i+1<=n && x){
        memo[i][j]=1;
        memo[i+1][j]=1;
        resp+=solve(i, j+1, x-1, y, cont+2);
        memo[i][j]=0;
        memo[i+1][j]=0;
    }
    if(y){
        memo[i][j]=1;
        resp+=solve(i, j+1, x, y-1, cont+1);
        memo[i][j]=0;
    }
    return resp;
}

int main(){
    fastio;
    cin >> m >> n >> a >> b;
    cout << solve(1, 1, a, b, 0) << endl;
    return 0;
}