#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
//#include <fstream>
#include <string>
#include <math.h>
#include <set>
#include <string>
#include <bitset>
//#include <fstream>
//#include <stack>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
//typedef pair<ll, P> T;

#define rep(i, n) for (ll i = 0; i < (n); i++)
#define revrep(i, n) for (ll i = (n) - 1; i >= 0; i--)
#define f first
#define s second
#define pb push_back

ll mod = 1000000007;
const ll INF = 100000000000010000;
//const ull B = 998244353;
//ll kai[3010];

//void pres(double A, ll x = 20) { printf("%.20f\n", x); }

vector<ll> dx = { 0, 1, 0, -1, 1, -1, 1, -1, 0};
vector<ll> dy = { 1, 0, -1, 0, 1, 1, -1, -1, 0};

void chmin(ll& x, ll y) {
	x = min(x, y);
}

void chmax(ll& x, ll y) {
	x = max(x, y);
}

ll pow_long(ll x, ll y) {
	ll res = 1;
	while (y > 0) {
		if (y % 2 == 1) res *= x;
		x *= x;
		y /= 2;
	}
	return res;
}

void test() {
	cout << "888888888888888888888888" << endl;
}

ll gcd(ll x, ll y) {
	if (y == 0) return x;
	return gcd(y, x % y);
}

ll pow_mod(ll x, ll k) {
	x %= mod;
	ll res = 1;
	while (k > 0) {
		if (k % 2) {
			res *= x; res %= mod;
		}
		x *= x; x %= mod;
		k /= 2;
	}
	return res;
}

ll div_mod(ll x) {
	return pow_mod(x, mod - 2);
}

//コンビネーション
const int MAXcomb = 1000010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
//facはn!,finvは1/n!
//invは逆元
void COMinit() {
	fac[0] = fac[1] = 1;
	finv[0] = finv[1] = 1;
	inv[1] = 1;
	for (int i = 2; i < MAXcomb; i++) {
		fac[i] = fac[i - 1] * i % mod;
		inv[i] = mod - inv[mod%i] * (mod / i) % mod;
		finv[i] = finv[i - 1] * inv[i] % mod;
	}
}
ll comb(int n, int k) {
	if (n < k) return 0;
	if (n < 0 || k < 0) return 0;
	return fac[n] * finv[k] % mod * finv[n - k] % mod;
}

ll N, X;
vector<ll> vec;

void solve() {
    cin >> N >> X;
	rep(i, N) {
		int a;
		cin >> a;
		if (a == X) continue;
		vec.push_back(a);
	}
	//sort(vec.begin(), vec.end());
	rep(i, vec.size()) {
		cout << vec[i] << ' ';
	}
}

int main() {
	cin.tie(0);
	ios::sync_with_stdio(false);
	ll T = 1;
	//cin >> T;
	rep(i, T) solve();
}

//                        YATIN KWATRA

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll                      long long
#define ar                      array
#define sz(v)                   (int)(v.size())
#define inf                     1e18
#define int                     ll
#define FIO                     ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ld                      long double
#define ull                     unsigned long long
#define endl                    "\n"
#define fo(i,a,b)               for(int i = a; i<=b ; i++)
#define rfo(i,a,b)              for(int i = a; i>=b ; i--)
#define vii                     vector<int>
#define pq                      priority_queue
#define uomii                   unordered_map<int,int,best_hash>
#define all(v)                  v.begin(),v.end()
#define mp                      make_pair
#define pb                      push_back
#define pob                     pop_back
#define ff                      first
#define ss                      second
#define pii                     pair<int,int>
#define mii                     map<int,int>
#define vvii                    vector<vii>
#define mod                     1000000007
#define MIN                     -1e9
#define pi                      3.1415926535897932384626433832795
#define cz(x)                   63 - __builtin_clzll(x)

using namespace std;
using namespace __gnu_pbds;
template<class T> using oset =  tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;


struct best_hash {
  static uint64_t splitmix64(uint64_t x) {

    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }

  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};

void INPUT()
{
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
}

/*
----------------------------------------------------------------
   -> Check For Overflows
   -> Out of Bounds
   -> Initialisations of global arrays and variables
----------------------------------------------------------------
*/


// so we will run all possible ways, as only two directions are allowed
// dp[turn][i][j] -> turn == 0 means tak turn and 1 means aoki turn
// we always the score difference between tak and aoki

// we maintain the score difference
// aoki tries to minimise
// tak tries to maximise


const int N = 2005;
int v[N][N];
int dp[2][N][N];
int n, m;


int khelo(int turn, int i, int j) {
  if (i == n - 1 and j == m - 1) return 0; // khel laye boht, chalo vapis
  int &ans = dp[turn][i][j];
  if (ans != -1e18) return ans;
  ans = -1e9;
  if (j + 1 < m) ans = max(ans, v[i][j + 1] - khelo(!turn, i, j + 1));
  if (i + 1 < n) ans = max(ans, v[i + 1][j] - khelo(!turn, i + 1, j));
  return ans;
}

void solve()
{
  cin >> n >> m;
  fo(i, 0, n - 1) {
    fo(j, 0, m - 1) {
      char ch;
      cin >> ch;
      if (ch == '+') v[i][j] = 1;
      else v[i][j] = -1;
      dp[0][i][j] = dp[1][i][j] = -1e18;
    }
  }

  int score = khelo(0, 0, 0);
  if (score > 0) cout << "Takahashi\n";
  else if (score < 0) cout << "Aoki\n";
  else cout << "Draw\n";
}

signed main() {

  FIO
  INPUT();

  int t;
  t = 1;
  //cin >> t;
  fo(i, 0, t - 1) {
    solve();
  }
  return 0;
}
