// D - Game in Momotetsu World
#include "bits/stdc++.h"
using namespace std;

#ifndef DEBUG

#define fundri 108
#define debug(...) 1729
#define endl '\n'

#endif

#define int int64_t

typedef pair<int, int> pii;
typedef vector<int> vi;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int rnd(int l = 0, int r = INT_MAX) {return uniform_int_distribution<int>(l, r)(rng);}

bool in_range(int x, int l, int r) {return l <= x && x <= r;}
template<typename H, typename ...T>void inp(H &head) {cin >> head;}
template<typename H, typename ...T>void inp(H &head, T &...tail) {cin >> head;inp(tail...);}
template<typename T>inline istream &operator >>(istream &in, vector<T> &a) {for(T &x : a)in >> x; return in;}
template<typename T, typename U>inline istream &operator >>(istream &in, pair<T, U> &a) {in >> a.first >> a.second; return in;}

// Multi-Dimension Vector
// Usage: vec<n, data-type> dp(dimention-1, dimention-2, ..., dimention-n, default = data-type())
template<int D, typename T> struct vec : public vector<vec<D - 1, T>> {
    static_assert(D >= 1, "Vector dimensions must be greater than zero !!");
    template<typename... Args>
    vec(int n = 0, Args... args) : vector<vec<D - 1, T>>(n, vec<D - 1, T>(args...)){}
};

template<typename T> struct vec<1, T> : public vector<T> {vec(int n = 0, T val = T()) : vector<T>(n, val){}};

const int inf = 1e15;
const bool testcases = false;

const bool ready = []() -> bool {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

#ifdef DHRUV_GHEEWALA
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    freopen("debug.txt", "w", stderr);
#endif

    return true;
}();

void solve(int tc);
int32_t main(int32_t argc, char **argv) {
    int TC = 1;
    if(testcases) cin >> TC;

    // Pre-Processing goes here...
    for(int tc = 1; tc <= TC; ++tc) {
        solve(tc);
        fundri;
    }
    exit(0);
}

int n, m;
vec<2, int> dp;
vec<2, char> grid;

int get(int i, int j) {
    if(!in_range(i, 0, n - 1) || !in_range(j, 0, m - 1)) {
        return -inf;
    }

    return grid[i][j] == '+' ? 1 : -1;
}

int rec(int i, int j) {
    if(i == n - 1 && j == m - 1)
        return 0;

    int &res = dp[i][j];
    if(res != -inf) return res;

    if(i + 1 >= n) {
        return res = get(i, j + 1) - rec(i, j + 1);
    }

    if(j + 1 >= m) {
        return res = get(i + 1, j) - rec(i + 1, j);
    }

    int down = get(i + 1, j) - rec(i + 1, j);
    int right = get(i, j + 1) - rec(i, j + 1);
    return res = max(down, right);
}

void solve(int tc) {
    cin >> n >> m;

    grid = vec<2, char>(n, m);
    cin >> grid;

    if(n == 1 && m == 1) {
        cout << "Draw" << endl;
        return;
    }
    
    dp = vec<2, int>(n, m, -inf);
    int diff = rec(0, 0);
    debug(dp);

    if(diff == 0) {
        cout << "Draw" << endl;
    } else if(diff > 0) {
        cout << "Takahashi" << endl; 
    } else {
        cout << "Aoki" << endl;
    }
}
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp> 
using namespace __gnu_pbds; 
#define ordered_set tree < pairs ,  null_type , greater<pairs>,  rb_tree_tag ,  tree_order_statistics_node_update > 
#define ll long long
#define lld long double
#define vc vector<ll>
const ll MOD=(1e9 +7);
typedef pair<ll,ll>pairs;
ll power(ll a, ll b){ll res=1;a=a%MOD;while(b>0){if(b&1){res=(res*a)%MOD;b--;}a=(a*a)%MOD;b>>=1;}
    return res;}

int main() {
	// your code goes here
	std::ios::sync_with_stdio(false);
	cin.tie(NULL);cout.tie(NULL);
	//Read the qstn. properlyyyyy!!!
	ll t,n,i,j,k,c,f,h,w;
	cin>>h>>w;
	vector<vc>a(h+1,vc(w+1)),dp(h+1,vc(w+1)),down(h+1,vc(w+1)),diag(h+1,vc(w+1)),rt(h+1,vc(w+1));
	char ch;
	for(i=1;i<=h;i++)
	{
	    
	    for(j=1;j<=w;j++){
	        cin>>ch;
	        if(ch=='.')
	        {
	            a[i][j]=1;
	        }
	        else a[i][j]=0;
	    }
	}
    dp[1][1]=1;
	for(i=1;i<=h;i++)
	{
	    for(j=1;j<=w;j++)
	    {
	        
	        if(a[i][j])
	        {
	            dp[i][j]+=(rt[i][j-1]+diag[i-1][j-1]+down[i-1][j])%MOD;
	            diag[i][j]=(dp[i][j]+diag[i-1][j-1])%MOD;
	            down[i][j]=(dp[i][j]+down[i-1][j])%MOD;
	            rt[i][j]=(dp[i][j]+rt[i][j-1])%MOD;
	        }
	    }
	}
	cout<<dp[h][w];
	return 0;
}
