from functools import lru_cache

def main():
    import sys
    sys.setrecursionlimit(1 << 25)
    input = sys.stdin.readline().strip()
    n = list(map(int, input.split()))
    n.sort()

    @lru_cache(maxsize=None)
    def compute(a, b, c, d, t, j, is_taro):
        if a == 0 and b == 0 and c == 0 and d == 0:
            return t - j

        piles = [a, b, c, d]
        max_diff = -float('inf') if is_taro else float('inf')

        for i in range(4):
            if piles[i] == 0:
                continue
            for k in [1, 2, 3]:
                if piles[i] < k:
                    continue
                new_piles = piles.copy()
                new_piles[i] -= k
                new_piles_sorted = sorted(new_piles)
                new_t, new_j = t, j

                if is_taro:
                    new_t += k
                else:
                    new_j += k

                if new_piles[i] == 0:
                    if is_taro:
                        steal = (new_j + 1) // 2
                        new_t += steal
                        new_j -= steal
                    else:
                        steal = (new_t + 1) // 2
                        new_j += steal
                        new_t -= steal

                res = compute(new_piles_sorted[0], new_piles_sorted[1], new_piles_sorted[2], new_piles_sorted[3], new_t, new_j, not is_taro)

                if is_taro:
                    if res > max_diff:
                        max_diff = res
                else:
                    if res < max_diff:
                        max_diff = res

        return max_diff

    result = compute(n[0], n[1], n[2], n[3], 0, 0, True)
    if result > 0:
        print("Taro")
    elif result < 0:
        print("Jiro")
    else:
        print("Draw")

if __name__ == "__main__":
    main()