//GIVE ME AC!!!!!!!!!!!!!!!!!
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include<bits/stdc++.h>
#define ll long long
#define floatset() fixed<<setprecision(15)
#define all(n) n.begin(),n.end()
#define rall(n) n.rbegin(),n.rend()
#define rep(i, s, n) for (ll i = s; i < (ll)(n); i++)
using namespace std;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll inf =1e18;
const ll MOD=1000000007;
const ll mod=998244353;
const double pi=acos(-1);
using P=pair<ll,ll>;
ll dp[2500][2500];
ll add(char c){
  if(c=='+'){
    return 1;
  }
  return -1;
}
int main(){
  ll h,w;
  cin>>h>>w;
  char c[h][w];
  rep(i,0,h){
    rep(j,0,w){
      cin>>c[i][j];
    }
  }
  dp[h-1][w-1]=0;
  for(ll i=h-1;i>=0;i--){
    for(ll j=w-1;j>=0;j--){
      if(i==h-1&&j==w-1){
        continue;
      }
      dp[i][j]=-inf;
      if(i<h-1){
        dp[i][j]=max(dp[i][j],add(c[i+1][j])-dp[i+1][j]);
      }
      if(j<w-1){
        dp[i][j]=max(dp[i][j],add(c[i][j+1])-dp[i][j+1]);
      }
    }
  }
  if(dp[0][0]>0){
    cout<<"Takahashi"<<endl;
  }
  if(dp[0][0]==0){
    cout<<"Draw"<<endl;
  }
  if(dp[0][0]<0){
    cout<<"Aoki"<<endl;
  }
}
#include <algorithm>
#include <bitset>
//#include <cmath>
//#include <complex>
#include <cctype>
#include <cstdio>
#include <cstdint>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <climits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#include <unordered_set>
#include <unordered_map>

using namespace std;

int64_t INF = LLONG_MAX;

void mod(int64_t &n){
    n %= 998244353;
}


int64_t factorial(int64_t n){
    if(n == 1 or n == 0){
        return 1;
    }else{
        int64_t tmp = n*factorial(n-1);
        mod(tmp);
        return tmp;
    }
}


//UnionFind木
class UnionFind {
private:
    //xの親はparent.at(x)．x==parent.at(x)ならxは根．
    vector<int> parent;
    
public:
    //コンストラクタ．parentの要素数をNで初期化．
    UnionFind(int N) : parent(N, -1){
    }
    
    //再帰的にxの根を探索．この時，経路圧縮を同時に行う．
    int root(int x){
        if(parent.at(x) < 0){
            return x;
        }else{
            parent.at(x) = root(parent.at(x));
            return parent.at(x);
        }
    }
    
    //xとyを接続．xをyの根に接続する．
    void unite(int x, int y){
        int rx = root(x);
        int ry = root(y);
        if(rx == ry){
            return;
        }else if(-(parent.at(rx)) > -(parent.at(ry))){
            swap(rx, ry);
        }
        
        //rxのサイズ <= ryのサイズ
        parent.at(ry) += parent.at(rx);
        parent.at(rx) = ry;
        return;
    }
    
    //xとyが同じ木に属するか判定．xの根とyの根が同じならtrue．
    bool isSame(int x, int y){
        return root(x) == root(y);
    }
    
    //xの属する木のサイズを取得．
    int size(int x){
        int rx = root(x);
        return parent.at(rx) * (-1);
    }
    
    void calc(int64_t &n){
        for(int i = 0; i < parent.size(); i++){
            if(parent.at(i) < 0){
                n *= factorial(-parent.at(i));
                mod(n);
            }
        }
    }
};


int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int N, K;
    
    cin >> N >> K;
    
    vector<vector<int>> a(N, vector<int>(N));
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            cin >> a.at(i).at(j);
        }
    }

    int64_t ans = 1;
    
    UnionFind uf1(N);
    
    //行スワップ
    for(int i = 0; i < N; i++){
        for(int j = i+1; j < N; j++){
            bool flag = true;
            for(int k = 0; k < N; k++){
                if(a.at(i).at(k) + a.at(j).at(k) > K){
                    flag = false;
                    break;
                }
            }
            
            if(flag){
                uf1.unite(i, j);
            }
        }
    }
    
    uf1.calc(ans);
    
    UnionFind uf2(N);
    //列スワップ
    for(int i = 0; i < N; i++){
        for(int j = i+1; j < N; j++){
            bool flag = true;
            for(int k = 0; k < N; k++){
                if(a.at(k).at(i) + a.at(k).at(j) > K){
                    flag = false;
                    break;
                }
            }
            if(flag){
                uf2.unite(i, j);
            }
        }
    }
    
    uf2.calc(ans);
    
    cout << ans << endl;


    return 0;
}
