#include <bits/stdc++.h>
#define DEBUG if(0)
#define lli long long int
#define ldouble long double
using namespace std;

const int maxN = 2e3; int n, m;
char a[maxN][maxN];

int getPoints(int i, int j, bool taka)
{
  if (!taka)
    return a[i][j] == '+' ? 1 : -1;
  return a[i][j] == '-' ? 1 : -1;
}
int memo[maxN][maxN][2]; bool visited[maxN][maxN][2];
int solve(int i = 0, int j = 0, bool taka = true)
{
  if (i == n - 1 && j == m - 1)
    return getPoints(i, j, taka);

  int &ans = memo[i][j][taka]; bool &vis = visited[i][j][taka];
  if (vis) return ans;
  vis = true;

  if (taka)
  {
    ans = -1e9;
    if (i + 1 < n) ans = max(ans, solve(i + 1, j, !taka));
    if (j + 1 < m) ans = max(ans, solve(i, j + 1, !taka));
    if (!(i == 0 && j == 0)) ans += getPoints(i, j, taka);
  }
  else
  {
    ans = 1e9;
    if (i + 1 < n) ans = min(ans, solve(i + 1, j, !taka));
    if (j + 1 < m) ans = min(ans, solve(i, j + 1, !taka));
    if (!(i == 0 && j == 0)) ans += getPoints(i, j, taka);
  }

  return ans;
}

int main()
{
  while (~scanf("%d %d", &n, &m))
  {
    for (int i = 0; i < n; i++)
      scanf(" %s", a[i]);

    memset(visited, false, sizeof(visited));
    int ans = solve();
    if (ans == 0 || (n == 1 && m == 1))
      printf("Draw\n");
    else if (ans > 0)
      printf("Takahashi\n");
    else
      printf("Aoki\n");
  }
  return 0;
}
/*
これを入れて実行
g++ code.cpp
./a.out
 */
 
#include <iostream>
#include <cstdio>
#include <stdio.h>
#include <vector>
#include <string>
#include <cstring>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#include <math.h>
#include <tuple>
#include <iomanip>
#include <bitset>
#include <functional>
#include <cassert>
#include <random>

#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
 
using namespace std;
typedef long long ll;
typedef long double ld;
 
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
 
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
 
bool greaterSecond(const pair<int, int>& f, const pair<int, int>& s){
    return f.second > s.second;
}
 
ll gcd(ll a, ll b){
	if (b == 0)return a;
	return gcd(b, a % b);
}
 
ll lcm(ll a, ll b){
    return a / gcd(a, b) * b;
}

ll conbinationMemo[100][100];

void cmemoInit(){
    rep(i, 100){
        rep(j, 100){
            conbinationMemo[i][j] = -1;
        }
    }
}
 
ll nCr(ll n, ll r){
    if(conbinationMemo[n][r] != -1) return conbinationMemo[n][r];
    if(r == 0 || r == n){
        return 1;
    } else if(r == 1){
        return n;
    }
    return conbinationMemo[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
 
ll nPr(ll n, ll r){
    r = n - r;
    ll ret = 1;
    for (ll i = n; i >= r + 1; i--) ret *= i;
    return ret;
}
//-----------------------ここから-----------
ll dp[2200][2200];
ll sumh[2200][2200], sumw[2200][2200], sum[2200][2200];
ll extGCD(ll a, ll b, ll &x, ll &y){
	if (b == 0){
		x = 1;
		y = 0;
		return a;
	}
 
	ll d = extGCD(b, a % b, y, x);
	y -= a / b * x;
	return d;
}
ll getinv(ll num){
    ll x, y;
    ll g = extGCD(num, MOD, x, y);
    while (x < 0) x += MOD;
    x %= MOD;
    return x;
}
int main(void){
    ll h, w;
    cin >> h >> w;
    vector<string> s(h);
    rep(i, h){
        cin >> s[i];
    }
    dp[0][0] = 1;
    sumh[0][0] = 1;
    sumw[0][0] = 1;
    sum[0][0] = 1;
    for(ll i = 0; i < h; i++){
        for(ll j = 0; j < w; j++){
            if(s[i][j] == '#') continue;
            dp[i + 1][j] += dp[i][j] + sumh[i][j];
            dp[i + 1][j] %= MOD;
            dp[i][j + 1] += dp[i][j] + sumw[i][j];
            dp[i][j + 1] %= MOD;
            dp[i + 1][j + 1] += dp[i][j] + sum[i][j];
            dp[i + 1][j + 1] %= MOD;

            sumh[i + 1][j] += dp[i][j] + sumh[i][j];
            sumh[i + 1][j] %= MOD;
            sumw[i][j + 1] += dp[i][j] + sumw[i][j];
            sumw[i][j + 1] %= MOD;
            sum[i + 1][j + 1] += dp[i][j] + sum[i][j];
            sum[i + 1][j + 1] %= MOD;
        }
    }

    cout << dp[h - 1][w - 1] * getinv(2) % MOD << endl;
}