Anton and Dasha like to play different games during breaks on checkered paper. By the 11th grade they managed to play all the games of this type and asked Vova the programmer to come up with a new game. Vova suggested to them to play a game under the code name "dot" with the following rules:  On the checkered paper a coordinate system is drawn. A dot is initially put in the position (x, y).  A move is shifting a dot to one of the pre-selected vectors. Also each player can once per game symmetrically reflect a dot relatively to the line y = x.  Anton and Dasha take turns. Anton goes first.  The player after whose move the distance from the dot to the coordinates' origin exceeds d, loses. Help them to determine the winner.

The first line of the input file contains 4 integers x, y, n, d ( - 200 ≤ x, y ≤ 200, 1 ≤ d ≤ 200, 1 ≤ n ≤ 20) — the initial coordinates of the dot, the distance d and the number of vectors. It is guaranteed that the initial dot is at the distance less than d from the origin of the coordinates. The following n lines each contain two non-negative numbers xi and yi (0 ≤ xi, yi ≤ 200) — the coordinates of the i-th vector. It is guaranteed that all the vectors are nonzero and different.

You should print "Anton", if the winner is Anton in case of both players play the game optimally, and "Dasha" otherwise.

NoteIn the first test, Anton goes to the vector (1;2), and Dasha loses. In the second test Dasha with her first move shifts the dot so that its coordinates are (2;3), and Anton loses, as he has the only possible move — to reflect relatively to the line y = x. Dasha will respond to it with the same move and return the dot in position (2;3).

import java.util.Comparator;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.List;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author AlexFetisov
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {

    static final int SHIFT = 200;
    private int[][][][] dp;
    private int n;
    private int d;
    private int[] dx;
    private int[] dy;

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int startX = in.nextInt(), startY = in.nextInt();
        n = in.nextInt();
        d = in.nextInt();
        d = d * d;
        dx = new int[n];
        dy = new int[n];
        for (int i = 0; i < n; ++i) {
            dx[i] = in.nextInt();
            dy[i] = in.nextInt();
        }
        dp = new int[500][500][2][2];
        ArrayUtils.fill(dp, -1);
        if (rec(startX, startY, 0, 0) == 1) {
            out.println("Anton");
        } else {
            out.println("Dasha");
        }
    }

    private int rec(int x, int y, int meDone, int oppDone) {
        if (x * x + y * y > d) {
            return 1;
        }
        if (dp[x + SHIFT][y + SHIFT][meDone][oppDone] != -1) {
            return dp[x + SHIFT][y + SHIFT][meDone][oppDone];
        }
        for (int i = 0; i < n; ++i) {
            if (rec(x + dx[i], y + dy[i], oppDone, meDone) == 0) {
                dp[x + SHIFT][y + SHIFT][meDone][oppDone] = 1;
                return 1;
            }
        }
        if (meDone == 0) {
            if (rec(y, x, oppDone, 1) == 0) {
                dp[x + SHIFT][y + SHIFT][meDone][oppDone] = 1;
                return 1;
            }
        }
        dp[x + SHIFT][y + SHIFT][meDone][oppDone] = 0;
        return 0;
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer stt;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
    }

    public String nextLine() {
        try {
            return reader.readLine().trim();
        } catch (IOException e) {
            return null;
        }
    }

    public String nextString() {
        while (stt == null || !stt.hasMoreTokens()) {
            stt = new StringTokenizer(nextLine());
        }
        return stt.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

}

class ArrayUtils {

    public static void fill(int[][] f, int value) {
        for (int i = 0; i < f.length; ++i) {
            Arrays.fill(f[i], value);
        }
    }

    public static void fill(int[][][] a, int value) {
        for (int i = 0; i < a.length; ++i) {
            fill(a[i], value);
        }
    }

    public static void fill(int[][][][] a, int value) {
        for (int i = 0; i < a.length; ++i) {
            fill(a[i], value);
        }
    }

}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Dot
{
	static int x,y,n,dx[],dy[], d, dp[][];
	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		x = sc.nextInt();
		y = sc.nextInt();
		n = sc.nextInt();
		d = sc.nextInt();

		dx = new int[n];
		dy = new int[n];
		for (int i = 0; i < n; i++)
		{
			dx[i] = sc.nextInt();
			dy[i] = sc.nextInt();
		}

		dp = new int[205*2][205*2];
		for (int i = 0; i < dp.length; i++)
			Arrays.fill(dp[i], -1);
		if(canWin(x,y) == 1)
			System.out.println("Anton");
		else
			System.out.println("Dasha");
	}

	private static int canWin(int i, int j)
	{
		if(dp[i+200][j+200] != -1)
			return dp[i+200][j+200];
		for (int m = 0; m < n; m++)
			if(sq((i+dx[m]))+sq(j+dy[m]) <= sq(d) && canWin(i+dx[m], j+dy[m]) == 0)
				return dp[i+200][j+200] = 1;
		return dp[i+200][j+200] = 0;
	}

	static int sq(int x)
	{
		return x*x;
	}
	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s)
		{
			br = new BufferedReader(new InputStreamReader(s));
		}
		public Scanner(String s) throws FileNotFoundException
		{
			br = new BufferedReader(new FileReader(new File((s))));
		}
		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());
		}
		public long nextLong() throws IOException
		{
			return Long.parseLong(next());
		}
		public String nextLine() throws IOException
		{
			return br.readLine();
		}
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class F {

	static int d, n, Vx[], Vy[];

	static Boolean[][][][] memo;

	static boolean win(int t, int r, int x, int y)
	{
		if(x * x + y * y > d * d)
			return true;
		if(memo[t][r][x + 200][y + 200] != null)
			return memo[t][r][x + 200][y + 200];
		boolean win = (1<<t & r) == 0 && !win(t ^ 1, r | 1<<t, y, x);
		for(int i = 0; i < n; ++i)
			win |= !win(t ^ 1, r, x + Vx[i], y + Vy[i]);
		return memo[t][r][x + 200][y + 200] = win;
	}

	public static void main(String[] args) throws IOException {

		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int x0 = sc.nextInt(), y0 = sc.nextInt();
		n = sc.nextInt();
		d = sc.nextInt();
		Vx = new int[n];
		Vy = new int[n];
		for(int i = 0; i < n; ++i)
		{
			Vx[i] = sc.nextInt();
			Vy[i] = sc.nextInt();
		}
		memo = new Boolean[2][4][401][401];
		out.println(win(0, 0, x0, y0)?"Anton":"Dasha");
		out.flush();
		out.close();
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if(x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for(int i = start; i < x.length(); i++)
				if(x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				}
				else
				{
					sb.append(x.charAt(i));
					if(dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg?-1:1);
		}

		public boolean ready() throws IOException {return br.ready();}

	}
}

// Don't place your source in a package
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

// Please name your class Main
public class Main {

	//static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    /*static int read() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
    static String readString() throws IOException {
        in.nextToken();
        return in.sval;
	}*/

	static Scanner in = new Scanner(System.in);

	public static void main (String[] args) throws java.lang.Exception {

		//InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int T=1;

		for(int t=0;t<T;t++){
			int x=Int();
			int y=Int();
			int n=Int();
			int d=Int();

			int A[][]=new int[n][2];
			for(int i=0;i<n;i++){
				int a=Int();
				int b=Int();
				A[i][0]=a;
				A[i][1]=b;
			}

			Solution sol=new Solution();
			sol.solution(A,x,y,d);
		}

		out.flush();
	}

	public static int Int(){
		return in.nextInt();
	}
	public static String Str(){
		return in.next();
	}
}

class Solution{
	//constant variable
	final int MAX=Integer.MAX_VALUE;
	final int MIN=Integer.MIN_VALUE;
	//Set<Integer>adjecent[];
	//////////////////////////////

	int d;
	Map<String,Boolean>map=new HashMap<>();
	public void solution(int A[][],int x,int y,int d){
		this.d=d;
		boolean res=dfs(A,x,y,0);
		if(res){
			msg("Anton");
		}else{
			msg("Dasha");
		}
	}

	public boolean dfs(int A[][],int tx,int ty,int turn){

		if(tx*tx+ty*ty>d*d){
			return true;
		}
		String state=tx+","+ty+","+turn;
		if(map.containsKey(state)){
			return map.get(state);
		}

		int next=0;
		if(turn==0)next=1;

		boolean res=false;

		for(int i=0;i<A.length;i++){
			boolean val=dfs(A,tx+A[i][0],ty+A[i][1],next);
			if(!val){
				res=true;
			}
		}

		map.put(state,res);

		return res;
	}

	public void swap(int A[],int l,int r){
		int t=A[l];
		A[l]=A[r];
		A[r]=t;
	}

	public long C(long fact[],int i,int j){ // C(20,3)=20!/(17!*3!)
		// take   a/b     where a=20!  b=17!*3!
		if(j>i)return 0;
		if(j==0)return 1;
		long mod=998244353;
		long a=fact[i];
		long b=((fact[i-j]%mod)*(fact[j]%mod))%mod;
		BigInteger B= BigInteger.valueOf(b);
		long binverse=B.modInverse(BigInteger.valueOf(mod)).longValue();
		return ((a)*(binverse%mod))%mod;
	}

	//map operation
	public void put(Map<Integer,Integer>map,int i){
		if(!map.containsKey(i))map.put(i,0);
		map.put(i,map.get(i)+1);
	}

	public void delete(Map<Integer,Integer>map,int i){
		map.put(i,map.get(i)-1);
		if(map.get(i)==0)map.remove(i);
	}

	/*public void tarjan(int p,int r){
		if(cut)return;
		List<Integer>childs=adjecent[r];
		dis[r]=low[r]=time;
		time++;

		//core for tarjan
		int son=0;
		for(int c:childs){
			if(ban==c||c==p)continue;
			if(dis[c]==-1){
				son++;
				tarjan(r,c);
				low[r]=Math.min(low[r],low[c]);
				if((r==root&&son>1)||(low[c]>=dis[r]&&r!=root)){
					cut=true;
					return;
				}
			}else{
				if(c!=p){
					low[r]=Math.min(low[r],dis[c]);
				}
			}
		}

	}*/

	//helper function I would use
	public void remove(Map<Integer,Integer>map,int i){
		map.put(i,map.get(i)-1);
		if(map.get(i)==0)map.remove(i);
	}

	public void ascii(String s){
		for(char c:s.toCharArray()){
			System.out.print((c-'a')+" ");
		}
		msg("");
	}

	public int flip(int i){
		if(i==0)return 1;
		else return 0;
	}

	public boolean[] primes(int n){
		boolean A[]=new boolean[n+1];
		for(int i=2;i<=n;i++){
			if(A[i]==false){
				for(int j=i+i;j<=n;j+=i){
					A[j]=true;
				}
			}
		}
		return A;
	}

	public void msg(String s){
		System.out.println(s);
	}

	public void msg1(String s){
		System.out.print(s);
	}

	public int[] kmpPre(String p){
		int pre[]=new int[p.length()];
		int l=0,r=1;
		while(r<p.length()){
			if(p.charAt(l)==p.charAt(r)){
				pre[r]=l+1;
				l++;r++;
			}else{
				if(l==0)r++;
				else l=pre[l-1];
			}
		}
		return pre;
	}

	public boolean isP(String s){
		int l=0,r=s.length()-1;
		while(l<r){
			if(s.charAt(l)!=s.charAt(r))return false;
			l++;r--;
		}
		return true;
	}

	public int find(int nums[],int x){//union find => find method
		if(nums[x]==x)return x;
		int root=find(nums,nums[x]);
		nums[x]=root;
		return root;
	}

	public int get(int A[],int i){
		if(i<0||i>=A.length)return 0;
		return A[i];
	}
	public int[] copy1(int A[]){
		int a[]=new int[A.length];
		for(int i=0;i<a.length;i++)a[i]=A[i];
		return a;
	}

	public void print1(int A[]){
		for(long i:A)System.out.print(i+" ");
		System.out.println();
	}
	public void print2(long A[][]){
		for(int i=0;i<A.length;i++){
			for(int j=0;j<A[0].length;j++){
				System.out.print(A[i][j]+" ");
			}System.out.println();
		}
	}

	public int min(int a,int b){
		return Math.min(a,b);
	}

	public int[][] matrixdp(int[][] grid) {
        if(grid.length==0)return new int[][]{};
        int res[][]=new int[grid.length][grid[0].length];
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                res[i][j]=grid[i][j]+get(res,i-1,j)+get(res,i,j-1)-get(res,i-1,j-1);
            }
        }
        return res;
    }

    public int get(int grid[][],int i,int j){
        if(i<0||j<0||i>=grid.length||j>=grid[0].length)return 0;
        return grid[i][j];
    }

	public int[] suffixArray(String s){
		int n=s.length();
		Suffix A[]=new Suffix[n];

		for(int i=0;i<n;i++){
			A[i]=new Suffix(i,s.charAt(i)-'a',0);
		}

		for(int i=0;i<n;i++){
			if(i==n-1){
				A[i].next=-1;
			}else{
				A[i].next=A[i+1].rank;
			}
		}
		Arrays.sort(A);

		for(int len=4;len<A.length*2;len<<=1){
			int in[]=new int[A.length];
			int rank=0;
			int pre=A[0].rank;
			A[0].rank=rank;
			in[A[0].index]=0;
			for(int i=1;i<A.length;i++){//rank for the first two letter
				if(A[i].rank==pre&&A[i].next==A[i-1].next){
					pre=A[i].rank;
					A[i].rank=rank;
				}else{
					pre=A[i].rank;
					A[i].rank=++rank;
				}
				in[A[i].index]=i;
			}

			for(int i=0;i<A.length;i++){
				int next=A[i].index+len/2;
				if(next>=A.length){
					A[i].next=-1;
				}else{
					A[i].next=A[in[next]].rank;
				}
			}

			Arrays.sort(A);
		}

		int su[]=new int[A.length];
		for(int i=0;i<su.length;i++){
			su[i]=A[i].index;
		}
		return su;
	}

}

//suffix array Struct
class Suffix implements Comparable<Suffix>{
	int index;
	int rank;
	int next;
	public Suffix(int i,int rank,int next){
		this.index=i;
		this.rank=rank;
		this.next=next;
	}

	@Override
	public int compareTo(Suffix other) {
		if(this.rank==other.rank){
			return this.next-other.next;
		}
		return this.rank-other.rank;
	}

	public String toString(){
		return this.index+"   "+this.rank+"   "+this.next+"  ";
	}
}

class Wrapper implements Comparable<Wrapper>{
	int spf;int cnt;
	public Wrapper(int spf,int cnt){
		this.spf=spf;
		this.cnt=cnt;
	}

	@Override
	public int compareTo(Wrapper other) {
		return this.spf-other.spf;
	}
}

    class Node{//what the range would be for that particular node
		boolean state=false;
        int l=0,r=0;
		int ll=0,rr=0;
        public Node(boolean state){
            this.state=state;
        }
    }

	class Seg1{
			int A[];
			public Seg1(int A[]){
				this.A=A;
			}

			public void update(int left,int right,int val,int s,int e,int id){
				if(left<0||right<0||left>right)return;
				if(left==s&&right==e){

					A[id]+=val;
					return;
				}
				int mid=s+(e-s)/2; //[s,mid] [mid+1,e]

				if(left>=mid+1){
					update(left,right,val,mid+1,e,id*2+2);
				}else if(right<=mid){
					update(left,right,val,s,mid,id*2+1);
				}else{
					update(left,mid,val,s,mid,id*2+1);
					update(mid+1,right,val,mid+1,e,id*2+2);
				}
			}

			public int query(int i,int add,int s,int e,int id){

				if(s==e&&i==s){
					return A[id]+add;
				}

				int mid=s+(e-s)/2; //[s,mid] [mid+1,e]

				if(i>=mid+1){
					return query(i,A[id]+add,mid+1,e,id*2+2);
				}else{
					return query(i,A[id]+add,s,mid,id*2+1);
				}
			}
	}

	 class MaxFlow{

		  public static List<Edge>[] createGraph(int nodes) {
			List<Edge>[] graph = new List[nodes];
			for (int i = 0; i < nodes; i++)
			  graph[i] = new ArrayList<>();
			return graph;
		  }

		  public static void addEdge(List<Edge>[] graph, int s, int t, int cap) {
			graph[s].add(new Edge(t, graph[t].size(), cap));
			graph[t].add(new Edge(s, graph[s].size() - 1, 0));
		  }

		  static boolean dinicBfs(List<Edge>[] graph, int src, int dest, int[] dist) {
			Arrays.fill(dist, -1);
			dist[src] = 0;
			int[] Q = new int[graph.length];
			int sizeQ = 0;
			Q[sizeQ++] = src;
			for (int i = 0; i < sizeQ; i++) {
			  int u = Q[i];
			  for (Edge e : graph[u]) {
				if (dist[e.t] < 0 && e.f < e.cap) {
				  dist[e.t] = dist[u] + 1;
				  Q[sizeQ++] = e.t;
				}
			  }
			}
			return dist[dest] >= 0;
		  }

		  static int dinicDfs(List<Edge>[] graph, int[] ptr, int[] dist, int dest, int u, int f) {
			if (u == dest)
			  return f;
			for (; ptr[u] < graph[u].size(); ++ptr[u]) {
			  Edge e = graph[u].get(ptr[u]);
			  if (dist[e.t] == dist[u] + 1 && e.f < e.cap) {
				int df = dinicDfs(graph, ptr, dist, dest, e.t, Math.min(f, e.cap - e.f));
				if (df > 0) {
				  e.f += df;
				  graph[e.t].get(e.rev).f -= df;
				  return df;
				}
			  }
			}
			return 0;
		  }

		  public static int maxFlow(List<Edge>[] graph, int src, int dest) {
			int flow = 0;
			int[] dist = new int[graph.length];
			while (dinicBfs(graph, src, dest, dist)) {
			  int[] ptr = new int[graph.length];
			  while (true) {
				int df = dinicDfs(graph, ptr, dist, dest, src, Integer.MAX_VALUE);
				if (df == 0)
				  break;
				flow += df;
			  }
			}
			return flow;
		  }

	 }

	 	 class Edge {
			int t, rev, cap, f;

			public Edge(int t, int rev, int cap) {
			  this.t = t;
			  this.rev = rev;
			  this.cap = cap;
			}
		  }

// practice with rainboy
import java.io.*;
import java.util.*;

public class CF69D extends PrintWriter {
	CF69D() { super(System.out, true); }
	Scanner sc = new Scanner(System.in);
	public static void main(String[] $) {
		CF69D o = new CF69D(); o.main(); o.flush();
	}

	static final int Z = 600;
	void main() {
		int x = sc.nextInt();
		int y = sc.nextInt();
		int n = sc.nextInt();
		int d = sc.nextInt();
		int[] xx = new int[n];
		int[] yy = new int[n];
		for (int i = 0; i < n; i++) {
			xx[i] = sc.nextInt();
			yy[i] = sc.nextInt();
		}
		boolean[][] win = new boolean[Z + 1][Z + 1];
		for (int x_ = 0; x_ <= Z; x_++)
			for (int y_ = 0; y_ <= Z; y_++)
				if ((x_ + x) * (x_ + x) + (y_ + y) * (y_ + y) > d * d)
					win[x_][y_] = true;
		for (int x_ = Z; x_ >= 0; x_--)
			for (int y_ = Z; y_ >= 0; y_--)
				if (!win[x_][y_])
					for (int i = 0; i < n; i++) {
						x = x_ - xx[i];
						y = y_ - yy[i];
						if (x >= 0 && y >= 0)
							win[x][y] = true;
					}
		println(win[0][0] ? "Anton" : "Dasha");
	}
}

// package CF;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class D69 {
	static int n, d, vx[], vy[];
	static int dp[][][][];
	static final int offset = 200;

	public static int solve(int id, int x, int y, int msk) {
		if (x * x + y * y > d * d)
			return id;

		if(dp[id][msk][x+offset][y+offset] != -1)
			return dp[id][msk][x+offset][y+offset];

		int next = id ^ 1;
		if ((msk | (1 << id)) == 0) {
			int newy = y > x ? x - (y - x) : x + (x - y);
			next = solve(id ^ 1, x, newy, msk | (1 << id));
		}

		for (int i = 0; i < n && next != id; i++)
			next = solve(id ^ 1, x + vx[i], y + vy[i], msk);

		return dp[id][msk][x+offset][y+offset] = next;
	}

	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);
		int x = in.nextInt();
		int y = in.nextInt();
		n = in.nextInt();
		d = in.nextInt();
		vx = new int[n];
		vy = new int[n];
		for(int i=0;i<n;i++){
			vx[i] = in.nextInt();
			vy[i] = in.nextInt();
		}
		dp = new int[2][4][405][405];
		for(int i=0;i<2;i++)
			for(int j=0;j<4;j++)
				for(int k=0;k<405;k++)
					Arrays.fill(dp[i][j][k], -1);

		System.out.println(solve(0, x, y, 0) == 0? "Anton":"Dasha");
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}
	}

}

import com.sun.org.apache.bcel.internal.generic.FieldGen;
import com.sun.org.apache.xpath.internal.operations.Bool;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Template implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    class GraphBuilder {
        int n, m;
        int[] x, y;
        int index;
        int[] size;

        GraphBuilder(int n, int m) {
            this.n = n;
            this.m = m;
            x = new int[m];
            y = new int[m];
            size = new int[n];
        }

        void add(int u, int v) {
            x[index] = u;
            y[index] = v;
            size[u]++;
            size[v]++;
            index++;
        }

        int[][] build() {
            int[][] graph = new int[n][];
            for (int i = 0; i < n; i++) {
                graph[i] = new int[size[i]];
            }
            for (int i = index - 1; i >= 0; i--) {
                int u = x[i];
                int v = y[i];
                graph[u][--size[u]] = v;
                graph[v][--size[v]] = u;
            }
            return graph;
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long[] readLongArray(int size) throws IOException {
        long[] res = new long[size];
        for (int i = 0; i < size; i++) {
            res[i] = readLong();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    <T> List<T>[] createGraphList(int size) {
        List<T>[] list = new List[size];
        for (int i = 0; i < size; i++) {
            list[i] = new ArrayList<>();
        }
        return list;
    }

    public static void main(String[] args) {
        new Template().run();
        // new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    int[] vx;
    int[] vy;
    int d;

    Boolean[] cache = new Boolean[410 * 410 * 2 * 2 * 2];

    boolean win(int x, int y, boolean useInvert, boolean useInvert2) {
        if (x * x + y * y > d * d) return true;
        int index = convertToInt(x, y, useInvert, useInvert2);
        if (cache[index] != null) return cache[index];
        boolean canWin = false;
        for (int i = 0; i < vx.length; i++) {
            int nx = x + vx[i];
            int ny = y + vy[i];
            if (!win(nx, ny, useInvert2, useInvert)) {
                canWin = true;
                break;
            }
        }
        if (!useInvert) {
            if (!win(y, x, useInvert2, true)) {
                canWin = true;
            }
        }
        return cache[index] = canWin;
    }

    int convertToInt(int x, int y, boolean useInvert, boolean useInvert2) {
        int res = (x + 205) * 405 + y + 205;
        res *= 2;
        if (useInvert) res++;
        res *= 2;
        if (useInvert2) res++;
        return res;
    }

    void solve() throws IOException {
        int x = readInt();
        int y = readInt();
        int n = readInt();
        d = readInt();

        vx = new int[n];
        vy = new int[n];

        for (int i = 0; i < n; i++) {
            vx[i] = readInt();
            vy[i] = readInt();
        }
        if (win(x, y, false, false)) {
            out.println("Anton");
        } else {
            out.println("Dasha");
        }

    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Dot_69D
{
	static int offset = 201;

	static boolean win(int x, int y)
	{
		if (mem[offset + x][offset + y] != null)
			return mem[offset + x][offset + y];
		for (int i = 0; i < n; i++)
			if (1l * (x + xs[i]) * (x + xs[i]) + 1l * (y + ys[i]) * (y + ys[i]) <= 1l * d * d)
				if (!win(x + xs[i], y + ys[i]))
					return mem[offset + x][offset + y] = true;
		return mem[offset + x][offset + y] = false;

	}

	static Boolean[][] mem;
	static int n, d;
	static int[] xs, ys;

	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		int x = sc.nextInt();
		int y = sc.nextInt();
		n = sc.nextInt();
		d = sc.nextInt();
		xs = new int[n];
		ys = new int[n];
		for (int i = 0; i < n; i++)
		{
			xs[i] = sc.nextInt();
			ys[i] = sc.nextInt();
		}
		mem = new Boolean[409][409];
		System.out.println(win(x, y) ? "Anton" : "Dasha");
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s)
		{
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException
		{
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException
		{
			return br.readLine();
		}

		public double nextDouble() throws IOException
		{
			return Double.parseDouble(next());
		}

		public boolean ready() throws IOException
		{
			return br.ready();
		}
	}
}

import java.util.*;
public class CodeforcesD69 {
	public static int sx, sy, d, n;
	public static int[][][] memo;
	public static int[] dx, dy;
	public static void main(String[] args){
		Scanner br = new Scanner(System.in);
		sx = br.nextInt();
		sy = br.nextInt();
		n = br.nextInt();
		d = br.nextInt();
		dx = new int[n];
		dy = new int[n];
		for(int i = 0;i<n;i++){
			dx[i] = br.nextInt();
			dy[i] = br.nextInt();
		}

		memo = new int[2][1000][1000];
		for(int i = 0;i<2;i++){
			for(int l = 0;l<1000;l++){
				Arrays.fill(memo[i][l], -1);
			}
		}

		int res = go(0, sx+500, sy+500);
		if(res == 0){
			System.out.println("Anton");
		}
		else{
			System.out.println("Dasha");
		}
	}
	public static int go(int turn, int x, int y){
		int rx = x-500;
		int ry = y-500;
		if(rx*rx+ry*ry > d*d){
			return turn;
		}

		if(memo[turn][x][y] != -1){
			return memo[turn][x][y];
		}

		int res = (1-turn);
		for(int i = 0;i<n;i++){
			int temp = go(1-turn, x+dx[i], y+dy[i]);
			if(temp == turn){
				res = turn;
				break;
			}
		}
		return memo[turn][x][y] = res;
	}
}

import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static class Reader
    {
        private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
        public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
        public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
        public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
        public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
        public int i(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
        public double d() throws IOException {return Double.parseDouble(s()) ;}
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
        public int[] arr(int n){int[] ret = new int[n];for (int i = 0; i < n; i++) {ret[i] = i();}return ret;}
    }

           //       |----|       /\      |    |   -----   |
           //       |   /       /  \     |    |     |     |
           //       |--/       /----\    |----|     |     |
           //       |   \     /      \   |    |     |     |
           //       |    \   /        \  |    |   -----   -------

    static int d,n,x1,y1;
    static int arr[][];
    static int cache[][][][][];
    public static int dfs(int x,int y,int chance,int flip1,int flip2)
    {
        if(Math.sqrt((x-300)*(x-300)+(y-300)*(y-300))>d)
        return 1;
        if(cache[x][y][chance][flip1][flip2]!=-1)
        return cache[x][y][chance][flip1][flip2];
        for(int i=0;i<n;i++)
        {
            if(dfs(x+arr[i][0],y+arr[i][1],chance^1,flip1,flip2)==0)
            return cache[x][y][chance][flip1][flip2]=1;
        }
        if(chance==0&&flip1==0)
        if(dfs(y,x,chance^1,1,flip2)==0)
        return cache[x][y][chance][flip1][flip2]=1;
        if(chance==1&&flip2==0)
        if(dfs(y,x,chance^1,flip1,1)==0)
        return cache[x][y][chance][flip1][flip2]=1;
        return cache[x][y][chance][flip1][flip2]=0;
    }
    public static void main(String[] args)throws IOException
    {
        PrintWriter out= new PrintWriter(System.out);
        Reader sc=new Reader();
        x1=sc.i();y1=sc.i();n=sc.i();d=sc.i();
        x1+=300;
        y1+=300;
        arr=new int[n][2];
        cache=new int[600][600][2][2][2];
        for(int i=0;i<600;i++)for(int j=0;j<600;j++)for(int k=0;k<2;k++)for(int l=0;l<2;l++)Arrays.fill(cache[i][j][k][l],-1);
        for(int i=0;i<n;i++)
        {
            arr[i][0]=sc.i();
            arr[i][1]=sc.i();
        }
        if(dfs(x1,y1,0,0,0)==1)
        out.println("Anton");
        else
        out.println("Dasha");
        out.flush();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class D implements Runnable {

	final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	final static String fileName = "";

	void init() throws IOException {
		if (ONLINE_JUDGE) {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		} else {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		}
	}

	public static void main(String[] args) {
		new D().run();
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws NumberFormatException, IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws NumberFormatException, IOException {
		return Long.parseLong(readString());
	}

	int[] readIntArray(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i = 0; i < size; i++) {
			arr[i] = readInt();
		}
		return arr;
	}

	static long timeIn;

	void time() {
		System.err.println("Time = " + (System.currentTimeMillis() - timeIn));
	}

	@Override
	public void run() {
		try {
			timeIn = System.currentTimeMillis();
			init();
			solve();
			out.close();
			time();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(-1);
		}
	}

	int[] vx, vy;
	int n;
	int d;
	int[][][][][] dp;

	boolean isWin(int x, int y, int playerNumber, boolean hasReverseFirst, boolean hasReverseSecond) {
		if (x * x + y * y > d * d) {
			return true;
		}

		int cachedValue = dp[playerNumber][hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT];
		if (cachedValue == WIN) {
			return true;
		}
		if (cachedValue == LOSE) {
			return false;
		}

		boolean isLose = true;
		for (int i = 0; i < n; i++) {
			isLose &= isWin(x + vx[i], y + vy[i], 1 - playerNumber, hasReverseFirst, hasReverseSecond);
		}
		if (playerNumber == 0 && hasReverseFirst) {
			isLose &= isWin(y, x, 1 - playerNumber, false, hasReverseSecond);
		}
		if (playerNumber == 1 && hasReverseSecond) {
			isLose &= isWin(y, x, 1 - playerNumber, hasReverseFirst, false);
		}

		dp[playerNumber][hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = isLose ? LOSE
				: WIN;
		return !isLose;
	}

	final int MAX_ABS_SHIFT = 404;
	final int WIN = 1;
	final int LOSE = 2;

	private void solve() throws IllegalArgumentException, IOException {
		int startX = readInt();
		int startY = readInt();
		n = readInt();
		d = readInt();

		dp = new int[2][2][2][1000][1000];

		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = readInt();
			vy[i] = readInt();
		}

		boolean firstWin = isWin(startX, startY, 0, true, true);
		out.println(firstWin ? "Anton" : "Dasha");
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Dot {

    static int N, D;
    static int[] vx, vy;
    static Boolean[][][][] dp;

    static long sq(long x) {
	return x * x;
    }

    static boolean solve(int p1, int p2, int x, int y) {
	if (sq(x) + sq(y) > sq(D))
	    return true;
	if (dp[p1][p2][x + 200][y + 200] != null)
	    return dp[p1][p2][x + 200][y + 200];
	boolean ans = false;
	if (p1 == 0)
	    ans |= !solve(p2, 1, y, x);
	for (int i = 0; i < N; i++)
	    ans |= !solve(p2, p1, x + vx[i], y + vy[i]);
	return dp[p1][p2][x + 200][y + 200] = ans;
    }

    public static void main(String[] args) throws IOException {
	MyScanner sc = new MyScanner(System.in);
	PrintWriter out = new PrintWriter(System.out);
	int x = sc.nextInt(), y = sc.nextInt();
	N = sc.nextInt();
	D = sc.nextInt();
	vx = new int[N];
	vy = new int[N];
	for (int i = 0; i < N; i++) {
	    vx[i] = sc.nextInt();
	    vy[i] = sc.nextInt();
	}
	dp = new Boolean[2][2][402][402];
	out.println(solve(0, 0, x, y) ? "Anton" : "Dasha");
	out.flush();
	out.close();
    }

    static class MyScanner {

	BufferedReader br;
	StringTokenizer st;

	MyScanner(InputStream is) {
	    br = new BufferedReader(new InputStreamReader(is));
	}

	String next() throws IOException {
	    while (st == null || !st.hasMoreTokens())
		st = new StringTokenizer(br.readLine());
	    return st.nextToken();
	}

	int nextInt() throws IOException {
	    return Integer.parseInt(next());
	}

	long nextLong() throws IOException {
	    return Long.parseLong(next());
	}

	boolean ready() throws IOException {
	    return br.ready();
	}
    }
}

import java.util.*;

public class P069D {
    private class Dot implements Comparable<Dot> {
        private final int x;
        private final int y;

        public Dot(int x, int y) {
            this.x    = x;
            this.y    = y;
        }

        public Dot addVec(MoveVec v) {
            return new Dot(x + v.x, y + v.y);
        }

        public Dot subVec(MoveVec v) {
            return new Dot(x - v.x, y - v.y);
        }

        public int compareTo(Dot other) {
            int rs1 = distSq(this);
            int rs2 = distSq(other);
            if (rs1 > rs2) return -1;
            if (rs1 < rs2) return 1;
            if (x > other.x) return -1;
            if (x < other.x) return 1;
            return 0;
        }

        public boolean equals(Object o) {
            if (o instanceof Dot) {
                Dot other = (Dot)o;
                return (x == other.x && y == other.y);
            }
            return false;
        }

        private int distSq(Dot p) {
            int dx = p.x - P0.x;
            int dy = p.y - P0.y;
            return dx * dx + dy * dy;
        }
    }

    private static class MoveVec {
        private final int x;
        private final int y;

        public MoveVec(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    private static class Board {
        private final int N = 401;
        // shifted by 200
        private final int SHIFT = 200;
        private boolean[][] visited = new boolean[N][N];
        private char[][] flag = new char[N][N];  // 0x1 - lose, 0x2 - win

        public boolean isVisited(Dot p) {
            return visited[p.x+SHIFT][p.y+SHIFT];
        }

        public void markVisited(Dot p) {
            visited[p.x+SHIFT][p.y+SHIFT] = true;
        }

        public void clearVisited() {
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    visited[i][j] = false;
                }
            }
        }

        public void markFlag(Dot p, char mf) {
            flag[p.x+SHIFT][p.y+SHIFT] |= mf;
        }

        public char getFlag(Dot p) {
            return flag[p.x+SHIFT][p.y+SHIFT];
        }
    }

    private final MoveVec[] vs;
    private final Dot P0;
    private final int D;
    private Board board = new Board();

    private PriorityQueue<Dot> dots = new PriorityQueue<Dot>();

    public P069D() {
        Scanner sc = new Scanner(System.in);
        int x0 = sc.nextInt();
        int y0 = sc.nextInt();
        P0 = new Dot(x0, y0);
        int N = sc.nextInt();
        D = sc.nextInt();

        vs = new MoveVec[N];
        for (int i = 0; i < N; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            vs[i] = new MoveVec(x, y);
        }

        findLossingDots();
        propagate();
    }

    private boolean inRange(Dot p) {
        return p.x * p.x + p.y * p.y <= D * D;
    }

    private void findLossingDots() {
        java.util.Queue<Dot> queue = new ArrayDeque<Dot>();

        queue.add(P0);
        board.markVisited(P0);
        while (!queue.isEmpty()) {
            Dot p = queue.poll();
            boolean found = false;
            for (MoveVec v: vs) {
                Dot pnext = p.addVec(v);
                if (!inRange(pnext)) continue;
                found = true;
                if (!board.isVisited(pnext)) {
                    queue.add(pnext);
                    board.markVisited(pnext);
                }
            }

            if (!found) {
                dots.add(p);
                board.markFlag(p, (char)1);
            }
        }

        board.clearVisited();
    }

    private boolean lessThanP0(Dot p) {
        return p.x < P0.x || p.y < P0.y;
    }

    private void propagate() {
        Dot p = dots.poll();
        while (!p.equals(P0)) {
            board.markVisited(p);
            char flag = board.getFlag(p);
            for (MoveVec v: vs) {
                Dot pprev = p.subVec(v);
                if (lessThanP0(pprev)) continue;

                if ((flag & 0x2) == 0) {  // L -> W
                    assert flag == 1;
                    board.markFlag(pprev, (char)0x2);
                } else {
                    board.markFlag(pprev, (char)0x1);
                }
                if (!board.isVisited(pprev)) {
                    dots.add(pprev);
                    board.markVisited(pprev);
                }
            }

            p = dots.poll();
        }
        System.out.println((board.getFlag(p) & 0x2) == 0 ? "Dasha" : "Anton");
    }

    public static void main(String[] args) {
        P069D solution = new P069D();
    }
}

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

/**
 * Author: dened
 * Date: 26.03.11
 */
public class D {
    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        int sx = in.nextInt();
        int sy = in.nextInt();
        int n = in.nextInt();
        int d = in.nextInt();
        int[] vx = new int[n];
        int[] vy = new int[n];
        for (int i = 0; i < n; ++i) {
            vx[i] = in.nextInt();
            vy[i] = in.nextInt();
        }
        boolean[][][][] win = new boolean[401][401][2][2];
        for (int a = 1; a >= 0; --a) {
            for (int b = 1; b >= 0; --b) {
                for (int x = 200; x >= -200; --x) {
                    for (int y = 200; y >= -200; --y) {
                        boolean t;
                        if (x*x + y*y > d*d) {
                            t = true;
                        }
                        else {
                            t = false;
                            if (a == 0) {
                                t = !win[y+200][x+200][b][1];
                            }
                            for (int i = 0; i < n; ++i) {
                                int nx = x + vx[i];
                                int ny = y + vy[i];
                                if (nx <= 200 && ny <= 200) {
                                    t = t || !win[nx+200][ny+200][b][a];
                                }
                            }
                        }
                        win[x+200][y+200][a][b] = t;
                    }
                }
            }
        }
        System.out.println(win[sx+200][sy+200][0][0] ? "Anton" : "Dasha");
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class D {
	static int[] vx, vy;
	static int[][] dp = new int[500][500];
	static int x, y, n, d;

	public static void main(String[] args) throws IOException {
		InputReader in = new InputReader();
		x = in.nextInt();
		y = in.nextInt();
		n = in.nextInt();
		d = in.nextInt();
		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = in.nextInt();
			vy[i] = in.nextInt();
		}
		for (int i = 0; i < dp.length; i++)
			Arrays.fill(dp[i], -1);
		int ans = solve(x, y);
		if (ans == 1) {
			System.out.println("Anton");
		} else {
			System.out.println("Dasha");
		}
	}

	public static int solve(int x, int y) {
		if (dp[x + 230][y + 230] != -1)
			return dp[x + 230][y + 230];
		int min = 2;
		for (int i = 0; i < n; i++)
			if ((x + vx[i])*(x + vx[i])+(y + vy[i])*(y + vy[i]) <= d*d)
				min = Math.min(min, solve(x + vx[i], y + vy[i]));
		if (min > 0)
			return dp[x + 230][y + 230] = -1;
		else
			return dp[x + 230][y + 230] = 1;
	}

	static class InputReader {
		BufferedReader in;
		StringTokenizer st;
		String cur;

		public InputReader() throws IOException {
			in = new BufferedReader(new InputStreamReader(System.in));
			st = new StringTokenizer(cur = in.readLine());
		}

		public boolean hasNext() throws IOException {
			if (!st.hasMoreElements()) {
				cur = in.readLine();
				if (cur == null)
					return false;
				st = new StringTokenizer(cur);
			}
			return true;
		}

		public String next() throws IOException {
			while (!st.hasMoreElements())
				st = new StringTokenizer(cur = in.readLine());
			return st.nextToken();
		}

		public int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws NumberFormatException, IOException {
			return Long.parseLong(next());
		}
	}
}

import java.util.*;

public class d {
	public static int n,d;
	public static int[] vecx, vecy;
	public static int[][][][][] memo;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int x = in.nextInt();
		int y = in.nextInt();
		n = in.nextInt();
		d = in.nextInt();
		vecx = new int[n];
		vecy = new int[n];
		for(int i=0; i<n; i++) {
			vecx[i] = in.nextInt();
			vecy[i] = in.nextInt();
		}
		memo = new int[410][410][2][2][2];
		if(win(x,y,0,0,0)==1)
			System.out.println("Anton");
		else
			System.out.println("Dasha");
	}
	public static int win(int x, int y, int p1flip, int p2flip, int player) {
		if(x*x+y*y>d*d)
			return 1;
		if(memo[x+202][y+202][p1flip][p2flip][player] != 0)
			return memo[x+202][y+202][p1flip][p2flip][player];
		boolean winner = false;
		if((player==0&&p1flip==0)||(player==1&&p2flip==0)) {
			if(win(y,x,player==0?1:p1flip,player==1?1:p2flip,1-player)==-1)
				winner = true;
		}
		for(int i=0; i<n; i++) {
			if(win(x+vecx[i],y+vecy[i],p1flip,p2flip,1-player)==-1)
				winner = true;
		}
		int res = winner?1:-1;
		return memo[x+202][y+202][p1flip][p2flip][player] = res;
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Dot {
	static int[] shiftX;
	static int[] shiftY;
	static int d;
	static Integer[][][][][] dp = new Integer[2][444][444][2][2];
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
		String s=r.readLine();
		String[] sp =s.split("[ ]+");
		int x = new Integer(sp[0]);
		int y = new Integer(sp[1]);
		int n = new Integer(sp[2]);
		d = new Integer(sp[3]);
		shiftX=new int[n];
		shiftY=new int[n];
		for (int i = 0; i < n; i++) {
			s=r.readLine();
			sp =s.split("[ ]+");
			shiftX[i]=new Integer(sp[0]);
			shiftY[i]=new Integer(sp[1]);
		}
		String[] res = {"Anton","Dasha"};
		System.out.println(res[go(0,x,y,0,0)]);
		}
	public static int go(int turn,int x,int y,int firstReflect , int secondReflect){
		if(x*x+y*y>d*d)
			return turn;
		if(dp[turn][x+222][y+222][firstReflect][secondReflect]!=null)return dp[turn][x+222][y+222][firstReflect][secondReflect];
		for(int i=0;i<shiftX.length;i++){
			if(go(1-turn,x+shiftX[i],y+shiftY[i],firstReflect,secondReflect)==turn){
				return dp[turn][x+222][y+222][firstReflect][secondReflect]=turn;
			}
		}
		if(turn==0&&firstReflect==0){
			if(go(1-turn,y,x,1,secondReflect)==turn){
				return dp[turn][x+222][y+222][firstReflect][secondReflect]=turn;
			}
		}
		if(turn==1&&secondReflect==0){
			if(go(1-turn,y,x,firstReflect,1)==turn){
				return dp[turn][x+222][y+222][firstReflect][secondReflect]=turn;
			}
		}
		return dp[turn][x+222][y+222][firstReflect][secondReflect]=1-turn;
	}

}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread() {
			public void run() {
				try {
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}.start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int d, n;
	int vect[][];

	boolean used[][][];

	int MAXX = 400;
	int MAXY = 400;
	boolean pp[][][];
	boolean dfs(boolean who, int x, int y){
		if(used[x+MAXX][y+MAXY][who? 1: 0])
			return pp[x+MAXX][y+MAXY][who? 1: 0];
		else
			used[x+MAXX][y+MAXY][who? 1: 0] = true;

		if(x*x + y*y > d*d){
			pp[x+MAXX][y+MAXY][who? 1: 0] = !who;
			return !who;		//anton on his turn already lost
		}

		boolean ret;

		if(!who){	//anton
			ret = false;
			for(int i = 0; i < n; i++)
//				if(!used[x + MAXX + vect[i][0]][y + MAXY + vect[i][1]][1])
					ret |= dfs(!who, x + vect[i][0], y + vect[i][1]);
		}
		else{
			ret = true;
			for(int i = 0; i < n; i++)
//				if(!used[x+MAXX + vect[i][0] ][y+MAXY + vect[i][1]][0])
					ret &= dfs(!who, x + vect[i][0], y + vect[i][1]);
		}
//		out.println(who+" "+x+" "+y+" ");
		pp[x+MAXX][y+MAXY][who? 1: 0] = ret;
		return ret;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();

		vect = new int[n][2];
		used = new boolean[MAXX * 2][MAXY * 2][2];
		pp = new boolean[MAXX * 2][MAXY * 2][2];

		for(int i = 0; i < n; i++){
			vect[i][0] = nextInt();
			vect[i][1] = nextInt();
		}

		boolean ans = dfs(false, x, y);
		if(ans)
			out.println("Anton");
		else
			out.println("Dasha");
		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.util.Scanner;

public class D {

    static boolean[][]f, calculated;
    static int[]x,y;
    static int d, n;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x0 = sc.nextInt()+210;
        int y0 = sc.nextInt()+210;
        n = sc.nextInt();
        d = sc.nextInt();
        x = new int[n+1];
        y = new int[n+1];
        for (int i = 1; i <= n; i++) {
            x[i] = sc.nextInt();
            y[i] = sc.nextInt();
        }
        f = new boolean[420][420];
        calculated = new boolean[420][420];
        dfs(y0, x0);
        if (f[y0][x0])
            System.out.println("Anton");
        else
            System.out.println("Dasha");
    }
    private static boolean dfs(int y0, int x0) {
        if ((x0-210)*(x0-210)+(y0-210)*(y0-210) > d*d)
            return true;
        if (calculated[y0][x0])
            return f[y0][x0];
        calculated[y0][x0] = true;
        for (int i = 1; i <= n; i++) {
            if (!dfs(y0+y[i], x0+x[i])){
                return f[y0][x0] = true;
            }
        }
        return f[y0][x0] = false;
    }
}

import java.io.*;
import java.util.*;

public class D {

    int n, d;
    int w[][];
    int dx[];
    int dy[];

    void solve() throws IOException {
        in("__std"); out("__std");

        int x = readInt();
        int y = readInt();
        n = readInt();
        d = readInt();

        dx = new int[n];
        dy = new int[n];

        for (int i = 0; i < n; ++i) {
            dx[i] = readInt();
            dy[i] = readInt();
        }

        w = new int[2 * d + 2][2 * d + 2];

        println(win(x, y) ? "Anton" : "Dasha");

        exit();
    }

    boolean win(int x, int y) {
        int sx = x + d;
        int sy = y + d;
        if (w[sx][sy] == 0) {
            w[sx][sy] = 2;
            for (int i = 0; i < n; ++i) {
                int xx = x + dx[i];
                int yy = y + dy[i];
                if (xx * xx + yy * yy <= d * d && !win(xx, yy)) {
                    w[sx][sy] = 1;
                    break;
                }
            }
        }
        return w[sx][sy] == 1;
    }

    void in(String name) throws IOException {
        if (name.equals("__std")) {
            in = new BufferedReader(new InputStreamReader(System.in));
        } else {
            in = new BufferedReader(new FileReader(name));
        }
    }

    void out(String name) throws IOException {
        if (name.equals("__std")) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(name);
        }
    }

    void exit() {
        out.close();
        System.exit(0);
    }

    int readInt() throws IOException {
        return Integer.parseInt(readToken());
    }

    long readLong() throws IOException {
        return Long.parseLong(readToken());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readToken());
    }

    String readLine() throws IOException {
        st = null;
        return in.readLine();
    }

    String readToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    boolean eof() throws IOException {
        return !in.ready();
    }

    void print(String format, Object ... args) {
        out.println(new Formatter().format(format, args));
    }

    void println(String format, Object ... args) {
        out.println(new Formatter().format(format, args));
    }

    void print(Object value) {
        out.print(value);
    }

    void println(Object value) {
        out.println(value);
    }

    void println() {
        out.println();
    }

    StringTokenizer st;

    BufferedReader in;
    PrintWriter out;

    public static void main(String[] args) throws IOException {
        new D().solve();
    }
}

import java.awt.Point;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.Polygon;
import java.io.*;
import java.math.BigInteger;
import static java.math.BigInteger.*;
import java.util.*;
public class B{
	int max=222;
	boolean[][][][]win=new boolean[2*max+1][2*max+1][2][2];
	boolean[][][][]vis=new boolean[2*max+1][2*max+1][2][2];
	int n;
	int[]dx;
	int[]dy;
	int d;
	void solve()throws Exception
	{
		int X=nextInt();
		int Y=nextInt();
		n=nextInt();
		d=nextInt();
		dx=new int[n];
		dy=new int[n];
		for(int i=0;i<n;i++)
		{
			dx[i]=nextInt();
			dy[i]=nextInt();
		}
		boolean res=go(X,Y,0,0);
		System.out.println(res?"Anton":"Dasha");
	}

    private boolean go(int x, int y,int c1,int c2) {
    	if(x*x+y*y>d*d)
    		return true;
		int sX=x+max;
		int sY=y+max;
		if(vis[sX][sY][c1][c2])
		{
			return win[sX][sY][c1][c2];
		}
		boolean res=false;
		for(int i=0;i<n;i++)
		{
			int nx=x+dx[i];
			int ny=y+dy[i];
			if(!go(nx, ny, c2, c1))
				res=true;
		}
		if(c1==0)
		{
			if(!go(y, x, c2, 1))
				res=true;
		}

		vis[sX][sY][c1][c2]=true;
		return win[sX][sY][c1][c2]=res;

	}

	BufferedReader reader;
	PrintWriter writer;
	StringTokenizer stk;
	void run()throws Exception
	{
		reader=new BufferedReader(new InputStreamReader(System.in));
		stk=null;
		writer=new PrintWriter(System.out);
		solve();
		reader.close();
		writer.close();
	}
	int nextInt()throws Exception
	{
		return Integer.parseInt(nextToken());
	}
	long nextLong()throws Exception
	{
		return Long.parseLong(nextToken());
	}
	double nextDouble()throws Exception
	{
		return Double.parseDouble(nextToken());
	}
	String nextString()throws Exception
	{
		return nextToken();
	}
	String nextLine()throws Exception
	{
		return reader.readLine();
	}
	String nextToken()throws Exception
	{
		if(stk==null || !stk.hasMoreTokens())
		{
			stk=new StringTokenizer(nextLine());
			return nextToken();
		}
		return stk.nextToken();
	}

	public static void main(String[]a) throws Exception
	{
		new B().run();

	}

}

import java.io.*;
import java.util.*;

public class D69 implements Runnable {

	int n, d;
	int[] dx, dy;
	int[][] f;

	void Solution() throws IOException {
		int x = nextInt(), y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		for (int i = 0; i < n; i++) {
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		f = new int[1000][1000];
		for (int i = 0; i < 1000; i++)
			for (int j = 0; j < 1000; j++)
				f[i][j] = -1;
		print(dfs(x + d, y + d) ? "Anton" : "Dasha");
	}

	boolean dfs(int x, int y) {
		if (x > 2 * d || y > 2 * d)
			return true;
		if (f[x][y] == 1)
			return true;
		if ((x - d) * (x - d) + (y - d) * (y - d) > d * d) {
			f[x][y] = 1;
			return true;
		}
		for (int i = 0; i < n; i++)
			if (!dfs(x + dx[i], y + dy[i])) {
				f[x][y] = 1;
				return true;
			}
		f[x][y] = 0;
		return false;
	}

	public static void main(String[] args) {
		new D69().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tokenizer;

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			Solution();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(0);
		}
	}

	void print(Object... obj) {
		for (int i = 0; i < obj.length; i++) {
			if (i != 0)
				out.print(" ");
			out.print(obj[i]);
		}
	}

	void println(Object... obj) {
		print(obj);
		out.println();
	}

	void halt() {
		out.close();
		System.exit(0);
	}

	String nextLine() throws IOException {
		return in.readLine();
	}

	String next() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(nextLine());
		return tokenizer.nextToken();
	}

	int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner r = new Scanner(System.in);

        int x = r.nextInt();
        int y = r.nextInt();
        n = r.nextInt();
        d = r.nextInt();

        a = new int[n][2];
        for(int i = 0; i < n; i++)
        for(int j = 0; j < 2; j++)
            a[i][j] = r.nextInt();

        dp = new int[410][410][2][2][2];
        for(int[][][][] i : dp)
        for(int[][][] j : i)
        for(int[][] k : j)
        for(int[] l : k)
            Arrays.fill(l, -1);

        int who = go(x, y, 1, 1, 0);

        if(who == 1)System.out.println("Anton");
        else System.out.println("Dasha");
    }

    static int n, d;
    static int[][] a;
    static int[][][][][] dp;
    static int off = 200;
    private static int go(int x, int y, int r1, int r2, int index) {
        if(d * d < x * x + y * y)return 1;

        if(dp[x + off][y + off][r1][r2][index] != -1)return dp[x + off][y + off][r1][r2][index];

        int win = 0;
        for(int i = 0; i < n; i++)
            win = Math.max(win, 1 - go(x + a[i][0], y + a[i][1], r1, r2, 1 - index));

        if(index == 0 && r1 > 0)
            win = Math.max(win, 1 - go(y, x, 0, r2, 1 - index));
        else if(index == 1 && r2 > 0)
            win = Math.max(win, 1 - go(y, x, r1, 0, 1 - index));

        return dp[x + off][y + off][r1][r2][index] = win;
    }
}

import java.util.Scanner;

public class D_Dot {

    /**
     * @param args
     */

    static int ix, iy, n, d;
    static int[][] memo;
    static int[] vx;
    static int[] vy;

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        ix = sc.nextInt();
        iy = sc.nextInt();
        n = sc.nextInt();
        d = sc.nextInt();

        memo = new int[401][401];
        vx = new int[n];
        vy = new int[n];

        for (int i = 0; i < n; i++) {
            vx[i] = sc.nextInt();
            vy[i] = sc.nextInt();
        }

        boolean result = foo(ix, iy);
        System.out.println(result ? "Anton" : "Dasha");

    }

    private static boolean foo(int x, int y){

        if(memo[x+200][y+200] != 0) return memo[x+200][y+200] == 1;

        boolean result = false;

        for (int i = 0; i < n; i++) {
            int nx = x+vx[i];
            int ny = y+vy[i];
            if(nx * nx + ny * ny <= d * d){
                if(! foo(nx, ny)){
                    result = true;
                    break;
                }
            }
        }

        memo[x+200][y+200] = result ? 1 : -1;
        return result;
    }

}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int m[][];
	int n,d;
	int dx[];
	int dy[];
	boolean test(int x, int y){
		if( d * d < (x - d) * (x - d) + (y - d) * (y-d))
			return true;
		if(m[x][y] != 0)
			return m[x][y] == 1;

		for(int i = 0; i < n; i++){
			if(!test(x + dx[i], y + dy[i])){
				m[x][y] = 1;
				return true;
			}
		}
		m[x][y] = -1;
		return false;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		m = new int[2 * d + 1][2 * d + 1];
		for(int i = 0; i < n; i++){
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		if(test(x + d,y + d))
			out.println("Anton");
		else
			out.println("Dasha");

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    final static int Base = 202;

    static class Vector {
        int x, y;

        Vector add(Vector o) {
            Vector ret = new Vector();
            ret.x = x + o.x;
            ret.y = y + o.y;
            return ret;
        }
    }

    static Vector[] vectors;
    static int dist;
    static int[][] map;

    static boolean isAway(Vector o) {
        double dx = o.x - Base;
        double dy = o.y - Base;
        if (Math.sqrt(dx * dx + dy * dy) > dist) {
            return true;
        }
        else {
            return false;
        }
    }

    static int getState(Vector cur) {
        if (map[cur.x][cur.y] != -1) {
            return map[cur.x][cur.y];
        }
        else {
            if (isAway(cur)) {
                return map[cur.x][cur.y] = 1;
            }
            map[cur.x][cur.y] = -1;
            for (int i = 0; i < vectors.length; i ++) {
                Vector tmp = cur.add(vectors[i]);
                int state = getState(tmp);
                if (state == -1) {
                    map[cur.x][cur.y] = 1;
                    break;
                }
            }
            return map[cur.x][cur.y];
        }
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner (System.in);
        map = new int[700][700];
        for (int i = 0; i < 700; i ++) {
            Arrays.fill(map[i], -1);
        }

        Vector start = new Vector();
        start.x = cin.nextInt() + Base;
        start.y = cin.nextInt() + Base;
        int n = cin.nextInt();
        dist = cin.nextInt();

        vectors = new Vector[n];
        for (int i = 0; i < n; i ++) {
            vectors[i] = new Vector();
            vectors[i].x = cin.nextInt();
            vectors[i].y = cin.nextInt();
        }

        if (getState(start) == 1) {
            System.out.println("Anton");
        }
        else {
            System.out.println("Dasha");
        }
    }

}

import java.io.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;

/**
 * @author Egor Kulikov (egor@egork.net)
 */
public class TaskD {
	private static final double CERTAINTY = 1e-6;

	@SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
	private final InputReader in;
	private final PrintWriter out;
	private final boolean testMode;

	private void solve() {
		int x = in.readInt();
		int y = in.readInt();
		int moveCount = in.readInt();
		int d = in.readInt();
		int[] dx = new int[moveCount];
		int[] dy = new int[moveCount];
		in.readIntArrays(dx, dy);
		int[][][][] result = new int[2 * d + 1][2 * d + 1][2][2];
		for (int[][][] array0 : result) {
			for (int[][] array1 : array0) {
				for (int[] array2 : array1)
					Arrays.fill(array2, -1);
			}
		}
		x += d;
		y += d;
		if (go(x, y, 0, 0, result, dx, dy, d))
			out.println("Anton");
		else
			out.println("Dasha");
	}

	private boolean go(int x, int y, int firstUsed, int secondUsed, int[][][][] result, int[] dx, int[] dy, int d) {
		if (x > 2 * d || y > 2 * d)
			return true;
		if (result[x][y][firstUsed][secondUsed] != -1)
			return result[x][y][firstUsed][secondUsed] == 1;
		if ((x - d) * (x - d) + (y - d) * (y - d) > d * d) {
			result[x][y][firstUsed][secondUsed] = 1;
			return true;
		}
		//noinspection SuspiciousNameCombination
		if (firstUsed == 0 && !go(y, x, secondUsed, 1, result, dx, dy, d)) {
			result[x][y][firstUsed][secondUsed] = 1;
			return true;
		}
		for (int i = 0; i < dx.length; i++) {
			if (!go(x + dx[i], y + dy[i], secondUsed, firstUsed, result, dx, dy, d)) {
				result[x][y][firstUsed][secondUsed] = 1;
				return true;
			}
		}
		result[x][y][firstUsed][secondUsed] = 0;
		return false;
	}

	private static List<Test> createTests() {
		List<Test> tests = new ArrayList<Test>();
		tests.add(new Test("0 0 2 3\n" +
				"1 1\n" +
				"1 2", "Anton"));
		tests.add(new Test("0 0 2 4\n" +
				"1 1\n" +
				"1 2", "Dasha"));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
//		tests.add(new Test("", ""));
		return tests;
	}

	private void run() {
		//noinspection InfiniteLoopStatement
//		while (true)
//		int testCount = in.readInt();
//		for (int i = 0; i < testCount; i++)
		solve();
		exit();
	}

	private TaskD() {
		@SuppressWarnings({"UnusedDeclaration"})
		String id = getClass().getName().toLowerCase();
		//noinspection EmptyTryBlock
		try {
//			System.setIn(new FileInputStream(id + ".in"));
//			System.setOut(new PrintStream(new FileOutputStream(id + ".out")));
//			System.setIn(new FileInputStream("input.txt"));
//			System.setOut(new PrintStream(new FileOutputStream("output.txt")));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		in = new StreamInputReader(System.in);
		out = new PrintWriter(System.out);
		testMode = false;
	}

	@SuppressWarnings({"UnusedParameters"})
	private static String check(String input, String result, String output) {
//		return strictCheck(result, output);
		return tokenCheck(result, output);
	}

	public static void main(String[] args) {
		if (args.length != 0 && args[0].equals("42"))
			test();
		else
			new TaskD().run();
	}

	private static void test() {
		List<Test> tests = createTests();
		int testCase = 0;
		List<Verdict> verdicts = new ArrayList<Verdict>();
		long maximalTime = 0;
		boolean ok = true;
		for (Test test : tests) {
			System.out.println("Test #" + testCase + ":");
			InputReader in = new StringInputReader(test.getInput());
			StringWriter out = new StringWriter(test.getOutput().length());
			System.out.println("Input:");
			System.out.println(test.getInput());
			System.out.println("Expected output:");
			System.out.println(test.getOutput());
			System.out.println("Execution result:");
			long time = System.currentTimeMillis();
			try {
				new TaskD(in, new PrintWriter(out)).run();
			} catch (TestException e) {
				time = System.currentTimeMillis() - time;
				maximalTime = Math.max(time, maximalTime);
				String result = out.getBuffer().toString();
				System.out.println(result);
				System.out.print("Verdict: ");
				String checkResult = check(test.getInput(), result, test.getOutput());
				if (checkResult == null) {
					System.out.print("OK");
					verdicts.add(Verdict.OK);
				} else {
					System.out.print("WA (" + checkResult + ")");
					verdicts.add(Verdict.WA);
					ok = false;
				}
				System.out.printf(" in %.3f s.\n", time / 1000.);
			} catch (Throwable e) {
				System.out.println("Exception thrown:");
				e.printStackTrace(System.out);
				verdicts.add(Verdict.RTE);
				ok = false;
			}
			testCase++;
			System.out.println("------------------------------------------------------------------");
		}
		System.out.println("==================================================================");
		System.out.println("Test results:");
		if (ok)
			System.out.printf("All test passed in %.3f s.\n", maximalTime / 1000.);
		else {
			for (int i = 0; i < verdicts.size(); i++)
				System.out.println("Test #" + i + ": " + verdicts.get(i));
		}
	}

	private static enum Verdict {
		OK, WA, RTE
	}

	private static String tokenCheck(String result, String output) {
		StringInputReader resultStream = new StringInputReader(result);
		StringInputReader outputStream = new StringInputReader(output);
		int index = 0;
		boolean readingResult = false;
		try {
			while (true) {
				readingResult = true;
				String resultToken = resultStream.readString();
				readingResult = false;
				String outputToken = outputStream.readString();
				if (!resultToken.equals(outputToken)) {
					try {
						//noinspection PointlessBooleanExpression
						if (CERTAINTY != 0 && isDoubleEquals(Double.parseDouble(outputToken.replace(',', '.')),
								Double.parseDouble(resultToken.replace(',', '.')), CERTAINTY)) {
							index++;
							continue;
						}
					} catch (NumberFormatException ignored) {
					}
					return "'" + outputToken + "' expected at " + index + " but '" + resultToken + "' received";
				}
				index++;
			}
		} catch (InputMismatchException e) {
			if (readingResult) {
				try {
					outputStream.readString();
					return "only " + index + " tokens received";
				} catch (InputMismatchException e1) {
					return null;
				}
			} else
				return "only " + index + " tokens expected";
		}
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static String strictCheck(String result, String output) {
		if (result.equals(output))
			return null;
		return "Result and expected output do not match";
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static boolean isDoubleEquals(double expected, double result, double certainty) {
		return Math.abs(expected - result) < certainty || Math.abs(expected - result) < certainty * expected;
	}

	private TaskD(InputReader in, PrintWriter out) {
		this.in = in;
		this.out = out;
		testMode = true;
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private void exit() {
		out.close();
		if (testMode)
			throw new TestException();
		System.exit(0);
	}

	private static class Test {
		private final String input;
		private final String output;

		private Test(String input, String output) {
			this.input = input;
			this.output = output;
		}

		public String getInput() {
			return input;
		}

		public String getOutput() {
			return output;
		}
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private abstract static class InputReader {
		public abstract int read();

		public int readInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long readLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuffer res = new StringBuffer();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private String readLine0() {
			StringBuffer buf = new StringBuffer();
			int c = read();
			while (c != '\n' && c != -1) {
				if (c != '\r')
					buf.appendCodePoint(c);
				c = read();
			}
			return buf.toString();
		}

		public String readLine() {
			String s = readLine0();
			while (s.trim().length() == 0)
				s = readLine0();
			return s;
		}

		public String readLine(boolean ignoreEmptyLines) {
			if (ignoreEmptyLines)
				return readLine();
			else
				return readLine0();
		}

		public BigInteger readBigInteger() {
			try {
				return new BigInteger(readString());
			} catch (NumberFormatException e) {
				throw new InputMismatchException();
			}
		}

		public char readCharacter() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			return (char) c;
		}

		public double readDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, readInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, readInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public int[] readIntArray(int size) {
			int[] array = new int[size];
			for (int i = 0; i < size; i++)
				array[i] = readInt();
			return array;
		}

		public long[] readLongArray(int size) {
			long[] array = new long[size];
			for (int i = 0; i < size; i++)
				array[i] = readLong();
			return array;
		}

		public double[] readDoubleArray(int size) {
			double[] array = new double[size];
			for (int i = 0; i < size; i++)
				array[i] = readDouble();
			return array;
		}

		public String[] readStringArray(int size) {
			String[] array = new String[size];
			for (int i = 0; i < size; i++)
				array[i] = readString();
			return array;
		}

		public char[][] readTable(int rowCount, int columnCount) {
			char[][] table = new char[rowCount][columnCount];
			for (int i = 0; i < rowCount; i++) {
				for (int j = 0; j < columnCount; j++)
					table[i][j] = readCharacter();
			}
			return table;
		}

		public void readIntArrays(int[]... arrays) {
			for (int i = 0; i < arrays[0].length; i++) {
				for (int j = 0; j < arrays.length; j++)
					arrays[j][i] = readInt();
			}
		}
	}

	private static class StreamInputReader extends InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public StreamInputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
	}

	private static class StringInputReader extends InputReader {
		private Reader stream;
		private char[] buf = new char[1024];
		private int curChar, numChars;

		public StringInputReader(String stream) {
			this.stream = new StringReader(stream);
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
	}

	private static class TestException extends RuntimeException {
	}
}

import java.io.*;
import java.util.*;

public class Main {
//	static Scanner in;
	static PrintWriter out;
	static StreamTokenizer in; static int next() throws Exception {in.nextToken(); return (int) in.nval;}

	public static void main(String[] args) throws Exception {
//		in = new Scanner(System.in);
		out = new PrintWriter(System.out);
		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

		int xx = next();
		int yy = next();
		int n = next();
		int d = next();

		int m = 405;
		boolean[][] win = new boolean[2*m][2*m];
		for (boolean[] w : win) Arrays.fill(w, true);

		int[] x = new int[n];
		int[] y = new int[n];
		for (int i = 0; i < n; i++) {
			x[i] = next(); y[i] = next();
		}

		for (int i = m - 1; i >= 0; i--)
			for (int j = m - 1; j >= 0; j--) {
				if ((i - 200)*(i - 200) + (j - 200)*(j - 200) <= d*d) {
					win[i][j] = false;
					for (int t = 0; t < n; t++) win[i][j] |= !win[i + x[t]][j + y[t]];
				}
			}

/*		for (int i = 200; i < 205; i++) {
			for (int j = 200; j < 205; j++) out.print(win[i][j] ? "1 " : "0 ");
			out.println();
		}*/

		out.println(win[200 + xx][200 + yy] ? "Anton" : "Dasha");

		out.close();
	}
}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main implements Runnable {

	int[] arrX;
	int[] arrY;
	int n;
	int d;
	int[][] __win;

	boolean win(int x, int y) {
		if (__win[x + 200][y + 200] == 0) {
			boolean canWin = false;
			for (int i = 0; i < n; ++i) {
				int nx  = x + arrX[i];
				int ny = y + arrY[i];
				if (nx * nx + ny * ny > d * d) {
					continue;
				}
				if (!win(nx, ny)) {
					canWin = true;
				}
			}
			if (canWin) {
				__win[x + 200][y + 200] = 1;
			} else {
				__win[x + 200][y + 200] = 2;
			}
		}
		return __win[x + 200][y + 200] == 1;
	}
	private void solve() throws IOException {
		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		arrX = new int[n];
		arrY = new int[n];
		__win = new int[500][500];
		for (int i = 0; i < n; ++i) {
			arrX[i] = nextInt();
			arrY[i] = nextInt();
		}
		if (win(x, y)) {
			out.println("Anton");
		} else {
			out.println("Dasha");
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new Thread(new Main()).start();

	}

	private BufferedReader br;
	private StringTokenizer st;
	private PrintWriter out;

	@Override
	public void run() {
		try {
			Locale.setDefault(Locale.US);
			br = new BufferedReader(new InputStreamReader(System.in));
			st = new StringTokenizer("");
			out = new PrintWriter(System.out);
			solve();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(-1);
		}

	}

	String next() throws IOException {
		while (!st.hasMoreTokens()) {
			String temp = br.readLine();
			if (temp == null) {
				return null;
			}
			st = new StringTokenizer(temp);
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	long nextLong() throws IOException {
		return Long.parseLong(next());
	}

}

import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class P069D {

	Scanner sc = new Scanner(System.in);

	int INF = 1 << 28;
	double EPS = 1e-9;

	int x, y, d, n;
	int[] xs, ys;

	void run() {
		x = sc.nextInt();
		y = sc.nextInt();
		n = sc.nextInt();
		d = sc.nextInt();
		xs = new int[n];
		ys = new int[n];
		for (int i = 0; i < n; i++) {
			xs[i] = sc.nextInt();
			ys[i] = sc.nextInt();
		}
		solve();
	}

	int[][][][] win;
	int dx, dy;

	void solve() {
		dx = dy = 220;
		win = new int[dx * 2][dy * 2][2][2];
		for (int x = 0; x < dx * 2; x++) {
			for (int y = 0; y < dy * 2; y++) {
				for (int i = 0; i < 2; i++) {
					for (int j = 0; j < 2; j++) {
						win[x][y][i][j] = -1;
					}
				}
			}
		}

		for (int y = dy - 1; y >= -dy + 1; y--) {
			for (int x = dx - 1; x >= -dx + 1; x--) {
				rec(x + dx, y + dy, 0, 0);
				rec(x + dx, y + dy, 1, 0);
				rec(x + dx, y + dy, 0, 1);
				rec(x + dx, y + dy, 1, 1);
			}
		}
		println(rec(x + dx, y + dy, 0, 0) == 1 ? "Anton" : "Dasha");
	}

	int recX, recY, recR0, recR1;

	// 1:win
	// 0:lose
	int hoge = 0;

	int rec(int x, int y, int r0, int r1) {
		// debug(x - dx, y - dy, r0, r1);
		hoge++;
		if (x < 0 || x >= dx * 2 || y < 0 || y >= dy * 2) {
//			return 1;
		}
		if ((x - dx) * (x - dx) + (y - dy) * (y - dy) > d * d) {
			hoge--;
			// return win[x][y][r0][r1] = 1;
			return 1;
		}
		if (win[x][y][r0][r1] >= 0) {
			hoge--;
			return win[x][y][r0][r1];
		}
		for (int i = 0; i < n; i++) {
			if (rec(x + xs[i], y + ys[i], r1, r0) == 0) {
				hoge--;
				return win[x][y][r0][r1] = 1;
			}
		}
		if (r0 == 0 && rec(y, x, r1, r0 + 1) == 0) {
			hoge--;
			return win[x][y][r0][r1] = 1;
		}
		hoge--;
		return win[x][y][r0][r1] = 0;
	}

	void println(String s) {
		System.out.println(s);
	}

	void print(String s) {
		System.out.print(s);
	}

	void debug(Object... os) {
		System.err.println(deepToString(os));
	}

	public static void main(String[] args) {
		Locale.setDefault(Locale.US);
		new P069D().run();
	}

}

import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

// Dot
// 2012/11/05
public class P069D{
	Scanner sc=new Scanner(System.in);

	int x, y, d, n;
	int[] xs, ys;

	void run(){
		x=sc.nextInt();
		y=sc.nextInt();
		n=sc.nextInt();
		d=sc.nextInt();
		xs=new int[n];
		ys=new int[n];
		for(int i=0; i<n; i++){
			xs[i]=sc.nextInt();
			ys[i]=sc.nextInt();
		}
		solve();
	}

	int[][][][] win;
	int dx, dy;

	void solve(){
		dx=dy=220;
		win=new int[dx*2][dy*2][2][2];
		for(int x=0; x<dx*2; x++){
			for(int y=0; y<dy*2; y++){
				for(int i=0; i<2; i++){
					for(int j=0; j<2; j++){
						win[x][y][i][j]=-1;
					}
				}
			}
		}
		println(rec(x+dx, y+dy, 0, 0)==1?"Anton":"Dasha");
	}

	int rec(int x, int y, int r0, int r1){
		if((x-dx)*(x-dx)+(y-dy)*(y-dy)>d*d){
			return 1;
		}
		if(win[x][y][r0][r1]>=0){
			return win[x][y][r0][r1];
		}
		for(int i=0; i<n; i++){
			if(rec(x+xs[i], y+ys[i], r1, r0)==0){
				return win[x][y][r0][r1]=1;
			}
		}
		if(r0==0&&rec(y, x, r1, r0+1)==0){
			return win[x][y][r0][r1]=1;
		}
		return win[x][y][r0][r1]=0;
	}

	void println(String s){
		System.out.println(s);
	}

	public static void main(String[] args){
		Locale.setDefault(Locale.US);
		new P069D().run();
	}
}

import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

// Dot
// 2012/11/05
public class P069D {
	Scanner sc = new Scanner(System.in);

	int x, y, d, n;
	int[] xs, ys;

	void run() {
		x = sc.nextInt();
		y = sc.nextInt();
		n = sc.nextInt();
		d = sc.nextInt();
		xs = new int[n];
		ys = new int[n];
		for (int i = 0; i < n; i++) {
			xs[i] = sc.nextInt();
			ys[i] = sc.nextInt();
		}
		solve();
	}

	int[][][][] win;
	int dx, dy;

	void solve() {
		dx = dy = 220;
		win = new int[dx * 2][dy * 2][2][2];
		for (int x = 0; x < dx * 2; x++) {
			for (int y = 0; y < dy * 2; y++) {
				for (int i = 0; i < 2; i++) {
					for (int j = 0; j < 2; j++) {
						win[x][y][i][j] = -1;
					}
				}
			}
		}

		println(rec(x + dx, y + dy, 0, 0) == 1 ? "Anton" : "Dasha");
	}

	int recX, recY, recR0, recR1;

	// 1:win
	// 0:lose
	int hoge = 0;

	int rec(int x, int y, int r0, int r1) {
		// debug(x - dx, y - dy, r0, r1);
		hoge++;
		if (x < 0 || x >= dx * 2 || y < 0 || y >= dy * 2) {
			// return 1;
		}
		if ((x - dx) * (x - dx) + (y - dy) * (y - dy) > d * d) {
			hoge--;
			// return win[x][y][r0][r1] = 1;
			return 1;
		}
		if (win[x][y][r0][r1] >= 0) {
			hoge--;
			return win[x][y][r0][r1];
		}
		for (int i = 0; i < n; i++) {
			if (rec(x + xs[i], y + ys[i], r1, r0) == 0) {
				hoge--;
				return win[x][y][r0][r1] = 1;
			}
		}
		if (r0 == 0 && rec(y, x, r1, r0 + 1) == 0) {
			hoge--;
			return win[x][y][r0][r1] = 1;
		}
		hoge--;
		return win[x][y][r0][r1] = 0;
	}

	void println(String s) {
		System.out.println(s);
	}

	void print(String s) {
		System.out.print(s);
	}

	void debug(Object... os) {
		System.err.println(deepToString(os));
	}

	public static void main(String[] args) {
		Locale.setDefault(Locale.US);
		new P069D().run();
	}

}

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class D69 {

    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int sx = in.nextInt(), sy = in.nextInt(), n = in.nextInt();
        dist = in.nextInt();
        x = new int[n];
        y = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = in.nextInt();
            y[i] = in.nextInt();
        }

        memo = new int[MAX_KEY];
        Arrays.fill(memo, -1);
        out.println(solve(sx, sy, 0, 0) == 0 ? "Dasha" : "Anton");

        out.flush();
    }

    static final int MAX_KEY = 1 << 20;
    static final int DELTA = 200;

    static int dist;
    static int[] x, y;
    static int[] memo;

    static int solve(int sx, int sy, int a, int d) {
        int key = ((sx + DELTA) << 11) + ((sy + DELTA) << 2) + (a << 1) + d;
        if (memo[key] != -1) return memo[key];

        boolean[] b = new boolean[x.length+5];
        for (int i = 0; i < x.length; i++) {
            int tx = sx + x[i], ty = sy + y[i];
            if (tx*tx + ty*ty > dist*dist) continue;
            b[solve(tx, ty, d, a)] = true;
        }

        if (a == 0) b[solve(sy, sx, d, 1)] = true;

        for (int i = 0;; i++)
            if (!b[i]) return memo[key] = i;
    }
}

import java.io.*;
import java.util.*;
import java.math.*;

public class D implements Runnable {

	static class State {
		int x;
		int y;
		boolean did1;
		boolean did2;

		public State(int x, int y, boolean did1, boolean did2) {
			super();
			this.x = x;
			this.y = y;
			this.did1 = did1;
			this.did2 = did2;
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + (did1 ? 1231 : 1237);
			result = prime * result + (did2 ? 1231 : 1237);
			result = prime * result + x;
			result = prime * result + y;
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			State other = (State) obj;
			if (did1 != other.did1)
				return false;
			if (did2 != other.did2)
				return false;
			if (x != other.x)
				return false;
			if (y != other.y)
				return false;
			return true;
		}

		State reverse() {
			return new State(y, x, did2, true);
		}

		State addVector(int vx, int vy) {
			return new State(x + vx, y + vy, did2, did1);
		}

		boolean isWin(int d) {
			return x * x + y * y > d * d;
		}

		@Override
		public String toString() {
			return "State [x=" + x + ", y=" + y + ", did1=" + did1 + ", did2="
					+ did2 + "]";
		}

	}

	static HashMap<State, Boolean> hm = new HashMap<State, Boolean>();

	static boolean go(State state, int n, int[] vx, int[] vy, int d) {
		if (hm.containsKey(state)) {
			return hm.get(state);
		}
		if (state.isWin(d)) {
			return true;
		}
		boolean ret = false;
		if (!state.did1) {
			State newState = state.reverse();
			ret |= !go(newState, n, vx, vy, d);
		}
		for (int i = 0; i < n; i++) {
			State newState = state.addVector(vx[i], vy[i]);
			ret |= !go(newState, n, vx, vy, d);
		}
		hm.put(state, ret);
		return ret;
	}

	void solve() {
		int startX = nextInt();
		int startY = nextInt();
		int n = nextInt();
		int d = nextInt();
		int[] vx = new int[n];
		int[] vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = nextInt();
			vy[i] = nextInt();
		}
		if (go(new State(startX, startY, false, false), n, vx, vy, d)) {
			out.println("Anton");
		} else {
			out.println("Dasha");
		}

	}

	FastScanner sc;
	PrintWriter out;

	public void run() {
		Locale.setDefault(Locale.US);
		try {
			sc = new FastScanner(System.in);
			out = new PrintWriter(System.out);
			solve();
			sc.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() {
		return sc.nextInt();
	}

	String nextToken() {
		return sc.nextToken();
	}

	long nextLong() {
		return sc.nextLong();
	}

	double nextDouble() {
		return sc.nextDouble();
	}

	BigInteger nextBigInteger() {
		return sc.nextBigInteger();
	}

	class FastScanner extends BufferedReader {
		StringTokenizer st;
		boolean eof;
		String buf;
		String curLine;
		boolean createST;

		public FastScanner(String fileName) throws FileNotFoundException {
			this(fileName, true);
		}

		public FastScanner(String fileName, boolean createST)
				throws FileNotFoundException {
			super(new FileReader(fileName));
			this.createST = createST;
			nextToken();
		}

		public FastScanner(InputStream stream) {
			this(stream, true);
		}

		public FastScanner(InputStream stream, boolean createST) {
			super(new InputStreamReader(stream));
			this.createST = createST;
			nextToken();
		}

		String nextLine() {
			String ret = curLine;
			if (createST) {
				st = null;
			}
			nextToken();
			return ret;
		}

		String nextToken() {
			if (!createST) {
				try {
					curLine = readLine();
				} catch (Exception e) {
					eof = true;
				}
				return null;
			}
			while (st == null || !st.hasMoreTokens()) {
				try {
					curLine = readLine();
					st = new StringTokenizer(curLine);
				} catch (Exception e) {
					eof = true;
					break;
				}
			}
			String ret = buf;
			buf = eof ? "-1" : st.nextToken();
			return ret;
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

		BigInteger nextBigInteger() {
			return new BigInteger(nextToken());
		}

		public void close() {
			try {
				buf = null;
				st = null;
				curLine = null;
				super.close();
			} catch (Exception e) {

			}
		}

		boolean isEOF() {
			return eof;
		}
	}

	public static void main(String[] args) {
		new D().run();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
    static int n;
    static int d;
    static int[] X;
    static int[] Y;
    static int[][][][] DP = new int[401][401][2][4];

    public static int get(int x, int y, int turn, int ref) {
        if (Math.sqrt(x * x + y * y) > d)
            return turn;
        if (DP[x + 200][y + 200][turn][ref] != -1)
            return DP[x + 200][y + 200][turn][ref];
        DP[x + 200][y + 200][turn][ref] = 1 - turn;
        for (int i = 0; i < n; i++) {
            if (X[i] == x && Y[i] == y)
                continue;
            int temp = get(x + X[i], y + Y[i], 1 - turn, ref);
            if (temp == turn)
                return DP[x + 200][y + 200][turn][ref] = turn;

        }
        if ((ref & (1 << turn)) == 0)
            return DP[x + 200][y + 200][turn][ref] = get(y, x, 1 - turn, ref
                    | (1 << turn));
        return DP[x + 200][y + 200][turn][ref];
    }

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] S = in.readLine().split(" ");
        int x = Integer.parseInt(S[0]);
        int y = Integer.parseInt(S[1]);
        n = Integer.parseInt(S[2]);
        d = Integer.parseInt(S[3]);
        X = new int[n];
        Y = new int[n];
        for (int i = 0; i < n; i++) {
            S = in.readLine().split(" ");
            X[i] = Integer.parseInt(S[0]);
            Y[i] = Integer.parseInt(S[1]);
        }
        for (int i = 0; i < 401; i++)
            for (int j = 0; j < 401; j++)
                for (int k = 0; k < 2; k++)
                    Arrays.fill(DP[i][j][k], -1);
        int ans = get(x, y, 0, 0);
        if (ans == 0)
            System.out.println("Anton");
        else
            System.out.println("Dasha");
    }
}

//package Div2_63;

import java.util.Scanner;

public class D1 {

	static boolean used [][][];
	static boolean ans [][][];
	static int vect [][];
	static int d,n;
	public static boolean dfs (int x,int y, boolean player)
	{
		if (used[x+400][y+400][player ? 1:0])
			return ans[x+400][y+400][player ? 1:0];
		used[x+400][y+400][player ? 1:0] = true;
		if (x*x + y*y > d*d){
			ans[x+400][y+400][player ? 1:0] = !player;
			return !player;
		}
		boolean can;
		if (!player)
		{
			can = false; // assume anton winning
			for (int i = 0; i < n; i++) {
				can |= dfs(x+vect[i][0],y+vect[i][1],!player);
			}
		}
		else
		{
			can = true; // assume Dasha winning
			for (int i = 0; i < n; i++) {
				can &= dfs (x+vect[i][0],y+vect[i][1],!player);
			}
		}
		ans[x+400][y+400][player ? 1: 0] = can;
		return can;
	}
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner s = new Scanner (System.in);
		int x = s.nextInt(), y = s.nextInt();
		n = s.nextInt();
		d = s.nextInt();
		vect = new int [n][2];
		for (int i = 0; i < n; i++) {
			vect[i][0] = s.nextInt();
			vect[i][1] = s.nextInt();
		}
		used = new boolean [400*2][400*2][2];
		ans = new boolean [400*2][400*2][2];
		boolean ans = dfs (x,y,false);
		if (ans) System.out.println("Anton");
		else System.out.println("Dasha");
	}

}

import java.util.*;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author jtimv
 */
public class D {

    Scanner in = new Scanner(System.in);

    public static void main(String[] args) {
        new D().main();
    }
    int x, y, n, d, d2;
    int vx[], vy[];
    int game[][] = new int[700][700];

    int dist2(int x, int y) {
        return x * x + y * y;
    }

    boolean isGoodPosition(int x, int y) {
        if (game[x + 200][y + 200] != 0) {
            return game[x + 200][y + 200] == +1;
        }
        for (int i = 0; i < n; i++) {
            int nx = x + vx[i],
                    ny = y + vy[i];
            if (dist2(nx, ny) <= d2) {
                if (!isGoodPosition(nx, ny)) {
                    game[x + 200][y + 200] = +1;
                    return true;
                }
            }
        }
        game[x + 200][y + 200] = -1;
        return false;
    }

    void main() {
        x = in.nextInt();
        y = in.nextInt();
        n = in.nextInt();
        d = in.nextInt();
        d2 = d * d;
        vx = new int[n];
        vy = new int[n];
        for (int i = 0; i < n; i++) {
            vx[i] = in.nextInt();
            vy[i] = in.nextInt();
        }
        System.out.println(isGoodPosition(x, y) ? "Anton" : "Dasha");
    }
}

//package round63;

import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class D {
	Scanner in;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int sx = ni();
		int sy = ni();
		int n = ni();
		int d = ni();
		int[] vx = new int[n];
		int[] vy = new int[n];
		for(int i = 0;i < n;i++){
			vx[i] = ni();
			vy[i] = ni();
		}
		int T = 200;
		boolean[][] dp = new boolean[401][401];
		for(int y = 200;y >= -200;y--){
			for(int x = 200;x >= -200;x--){
				if(x*x+y*y > d*d){
					dp[x+T][y+T] = true;
				}else{
					boolean win = false;
					for(int i = 0;i < n;i++){
						int nx = x+vx[i];
						int ny = y+vy[i];
						if(nx*nx+ny*ny <= d*d){
							if(!dp[nx+T][ny+T]){
								win = true;
								break;
							}
						}
					}
					dp[x+T][y+T] = win;
				}
			}
		}

		out.println(dp[sx+T][sy+T] ? "Anton" : "Dasha");
	}

	void run() throws Exception
	{
		in = INPUT.isEmpty() ? new Scanner(System.in) : new Scanner(INPUT);
		out = new PrintWriter(System.out);

		solve();
		out.flush();
	}

	public static void main(String[] args) throws Exception
	{
		new D().run();
	}

	int ni() { return Integer.parseInt(in.next()); }
	void tr(Object... o) { if(INPUT.length() != 0)System.out.println(Arrays.deepToString(o)); }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.HashMap;
import java.util.TreeSet;

public class Main {
	private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(
			new InputStreamReader(System.in)));
	private static PrintWriter out = new PrintWriter(System.out);

	private static int nextInt() throws Exception {
		in.nextToken();
		return (int) in.nval;
	}

	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}

	public static void main(String[] args) throws Exception {
		int x = nextInt(), y = nextInt();
		int n = nextInt();
		d = nextInt();
		v = new int[n][];
		for (int i = 0; i < n; i++) {
			v[i] = new int[] { nextInt(), nextInt() };
		}
		dp = new int[430][430][2][2];
		out.println(f(x, y, 1, 1) == 1 ? "Anton" : "Dasha");
		out.flush();
	}

	private static int[][] v;
	private static int[][][][] dp;
	private static int d;

	private static double EPS = 1e-6;

	private static final int offset = 210;

	private static int f(int x, int y, int cani, int cano) { //1 - I win, 2 - I lose
		if (Math.sqrt(x*x + y*y) > d + EPS) {
			return 1;
		}
		int X = x + offset, Y = y + offset;
		if (dp[X][Y][cani][cano] > 0) {
			return dp[X][Y][cani][cano];
		}

		for (int[] vector : v) {
			if (f(x + vector[0], y + vector[1], cano, cani) == 2) {
				return dp[X][Y][cani][cano] = 1;
			}
		}

		if (cani == 1) {
			if (f(y, x, cano, 0) == 2) {
				return dp[X][Y][cani][cano] = 1;
			}
		}

		return dp[X][Y][cani][cano] = 2;
	}
}

import java.util.Arrays;
import java.util.Scanner;

public class D {
    static int[][][][][] dp;
    static int[] xs;
    static int[] ys;
    static int end,offx,offy;
    public static int solve(int curx,int cury,int turn,int hasa,int hasb) {
        double d=(curx-offx)*(curx-offx)+(cury-offy)*(cury-offy);
        if(d>end) {
            if(turn==0) return -1000;       //anton wins
            else return 1000;               //dahsa wins
        }
        if(dp[curx][cury][turn][hasa][hasb]!=-1) return dp[curx][cury][turn][hasa][hasb];
        if(turn ==0) {
            int min=100000;
            for(int i=0;i<xs.length;i++) {
                min=Math.min(min,solve(curx+xs[i],cury+ys[i],(turn+1)%2,hasa,hasb));
            }
            if(hasa==1) {
                min=Math.min(min,solve(cury,curx,(turn+1)%2,hasa-1,hasb));
            }
            return dp[curx][cury][turn][hasa][hasb]=min;
        }
        else {
            int max=-100000;
            for(int i=0;i<xs.length;i++) {
                max=Math.max(max,solve(curx+xs[i],cury+ys[i],(turn+1)%2,hasa,hasb));
            }
            if(hasb==1) {
                max=Math.max(max,solve(cury,curx,(turn+1)%2,hasa,hasb-1));
            }
            return dp[curx][cury][turn][hasa][hasb]=max;
        }
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int x=sc.nextInt();
        int y=sc.nextInt();
        int c=sc.nextInt();
        end=sc.nextInt();
        end*=end;
        //System.out.println(end);
        xs=new int[c];
        ys=new int[c];
        for(int i=0;i<xs.length;i++) {
            xs[i]=sc.nextInt();
            ys[i]=sc.nextInt();
        }
        offx=0;offy=0;
        if(x<0) offx=-1*x;
        if(y<0) offy=-1*y;
        dp=new int[401][401][2][2][2];
        for(int i=0;i<401;i++)
            for(int j=0;j<401;j++)
                for(int k=0;k<2;k++)
                    for(int u=0;u<2;u++)
                        Arrays.fill(dp[i][j][k][u],-1);
        //System.out.println(y+offy);
        int res=solve(x+offx,y+offy,0,1,1);
        //System.out.println(res);
        if(res==-1000) System.out.println("Anton");
        else System.out.println("Dasha");
    }
}

import java.awt.Point;
import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class ProblemD_63 {

    final boolean ONLINE_JUDGE=System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok=new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in=new BufferedReader(new InputStreamReader(System.in));
            out =new PrintWriter(System.out);
        }
        else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok=new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemD_63().run();
    }

    public void run(){
        try{
            long t1=System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2=System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    int n;
    int d;
    Point[] v;
    int[][][] used;

    void solve() throws IOException{
        int x0 = readInt();
        int y0 = readInt();
        n = readInt();
        d = readInt();
        v = new Point[n];
        used = new int[4][600][600];
        for (int i = 0; i < n; i++){
            v[i] = new Point(readInt(), readInt());
        }
        if (dfs(1, x0, y0, false, false) == 1){
            out.print("Dasha");
        }else{
            out.print("Anton");
        }
    }

    double d(int x, int y){
        return sqrt(x*x + y*y);
    }

    int ind(int num, boolean f1, boolean f2){
        if (num == 1){
            boolean r = f1;
            f1 = f2;
            f2 = r;
        }
        return f1? f2? 3: 2: f2? 1: 0;
    }

    int dfs(int num, int x, int y, boolean f1, boolean f2){
        int ind = ind(num, f1, f2);
        if (used[ind][x+200][y+200] != 0){
            return used[ind][x+200][y+200];
        }
        if (d(x, y) > d){
            return used[ind][x+200][y+200] = -1;
        }
        if (num == 1 && !f1){
            if (dfs(1 - num, y, x, !f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        if (num == 0 && !f2){
            if (dfs(1 - num, y, x, f1, !f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        for (int i = 0; i < n; i++){
            if (dfs(1 - num, x + v[i].x, y + v[i].y, f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        return used[ind][x+200][y+200] = 1;
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import static java.lang.Double.*;
import static java.math.BigInteger.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;

public class Main implements Runnable {

	// private long start;

	private void solve() throws IOException {
		// start = System.currentTimeMillis();
		init();
		readData();
		processing();
	}

	private void init() {
		dp = new int[2][2][2][BASE<<1][BASE<<1];
		for (int i = 0; i < 2; ++i) {
			for (int j = 0; j < 2; ++j) {
				for (int l = 0; l < 2; ++l) {
					for (int x = 0; x < BASE<<1; ++x) {
						for (int y = 0; y < BASE<<1; ++y) {
							dp[i][j][l][x][y] = -1;
						}
					}
				}
			}
		}
	}

	private int sqr(int x) {
		return x*x;
	}

	private boolean isGood(int x, int y) {
		return sqr(x - BASE) + sqr(y - BASE) <= maxDistance;
	}

	private int rec(int turn, int canRotateAnton, int canRotateDasha, int xTable, int yTable) {
		if (dp[turn][canRotateAnton][canRotateDasha][xTable][yTable] == -1) {
			dp[turn][canRotateAnton][canRotateDasha][xTable][yTable] = 0;
			if (turn == 0 && canRotateAnton == 1) {
				if (rec(1, 0, canRotateDasha, yTable, xTable) == 0) {
					dp[0][1][canRotateDasha][xTable][yTable] = 1;
				}
			}
			else if (turn == 1 && canRotateDasha == 1) {
				if (rec(0, canRotateAnton, 0, yTable, xTable) == 0) {
					dp[1][canRotateAnton][1][xTable][yTable] = 1;
				}
			}
			if (dp[turn][canRotateAnton][canRotateDasha][xTable][yTable] == 0) {
				for (Vector vector: vectors) {
					int nx = xTable + vector.dx;
					int ny = yTable + vector.dy;
					if (isGood(nx, ny)) {
						if (rec(1^turn, canRotateAnton, canRotateDasha, nx, ny) == 0) {
							dp[turn][canRotateAnton][canRotateDasha][xTable][yTable] = 1;
							break;
						}
					}
				}
			}
		}
		return dp[turn][canRotateAnton][canRotateDasha][xTable][yTable];
	}

	private void processing() {
		if (rec(0, 1, 1, xStart+BASE, yStart+BASE) == 1) {
			println("Anton");
		}
		else {
			println("Dasha");
		}
	}

	private void readData() throws IOException {
		xStart = nextInt();
		yStart = nextInt();
		int n = nextInt();
		maxDistance = nextInt();
		maxDistance *= maxDistance;
		vectors = new ArrayList<Vector>();
		for (int i = 0; i < n; ++i) {
			vectors.add(new Vector());
		}
	}

	private int xStart;
	private int yStart;
	private int maxDistance;
	private List<Vector> vectors;
	private int[][][][][] dp;

	private class Vector {

		public Vector() throws IOException {
			dx = nextInt();
			dy = nextInt();
		}

		public int dx;
		public int dy;
	}

	private static final int BASE = 203;

	public static void main(String[] args) throws InterruptedException {
		new Thread(null, new Runnable() {
			public void run() {
				new Main().run();
			}
		}, "1", 1 << 24).start();
	}

	// @Override
	public void run() {
		try {
			boolean onlineJudge = System.getProperty("ONLINE_JUDGE") != null;
			reader = onlineJudge ? new BufferedReader(new InputStreamReader(
					System.in)) : new BufferedReader(
					new FileReader("input.txt"));
			writer = onlineJudge ? new PrintWriter(new BufferedWriter(
					new OutputStreamWriter(System.out))) : new PrintWriter(
					new BufferedWriter(new FileWriter("output.txt")));
			Locale.setDefault(Locale.US);
			tokenizer = null;
			solve();
			writer.flush();
		} catch (Exception error) {
			error.printStackTrace();
			System.exit(1);
		}
	}

	class InputReader {

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int readInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long readLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuffer res = new StringBuffer();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private String readLine0() {
			StringBuffer buf = new StringBuffer();
			int c = read();
			while (c != '\n' && c != -1) {
				if (c != '\r')
					buf.appendCodePoint(c);
				c = read();
			}
			return buf.toString();
		}

		public String readLine() {
			String s = readLine0();
			while (s.trim().length() == 0)
				s = readLine0();
			return s;
		}

		public String readLine(boolean ignoreEmptyLines) {
			if (ignoreEmptyLines)
				return readLine();
			else
				return readLine0();
		}

		public char readCharacter() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			return (char) c;
		}

		public double readDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, readInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, readInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		private InputStream stream;
		private byte[] buf = new byte[1 << 16];
		private int curChar;
		private int numChars;
	}

	private class Parser {

		public Parser(InputStream in) {
			din = new DataInputStream(in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public byte c;

		public int nextInt() throws IOException {
			int value = 0;
			c = read();
			while (c <= ' ')
				c = read();
			boolean neg = c == '-';
			if (neg)
				c = read();
			do {
				value = value * 10 + c - 48;
				c = read();
			} while (c > ' ');
			if (neg) {
				return -value;
			} else {
				return value;
			}
		}

		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		public byte read() throws IOException {
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		final private int BUFFER_SIZE = 1 << 16;
	}

	private BufferedReader reader;
	private PrintWriter writer;
	private StringTokenizer tokenizer;

	private void println() {
		writer.println();
	}

	private void print(Object obj) {
		writer.print(obj);
	}

	private void println(Object obj) {
		writer.println(obj);
	}

	private void printf(String f, Object... obj) {
		writer.printf(f, obj);
	}

	private int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	private long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	private double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	private String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
}

import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.fill;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;

public class Main {
	public static void main(String[] args) throws IOException {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					try {
						if (new File("input.txt").exists())
							System.setIn(new FileInputStream("input.txt"));
					} catch (SecurityException e) {}
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, "1", 1L << 24).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int OFFSET = 500;

	int N;
	int D;
	int[][] dx;
	int[][] dy;

	int[][] mem;

	int UNKNOWN = 0;
	int WIN = 1;
	int LOOSE = 2;

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		N = nextInt();
		int d = nextInt(); D = d * d;

		dx = new int [2][N];
		dy = new int [2][N];

		for (int i = 0; i < N; i++) {
			dy[1][i] = dx[0][i] = nextInt();
			dx[1][i] = dy[0][i] = nextInt();
		}

		mem = new int [2 * OFFSET + 1][2 * OFFSET + 1];
		out.println(rec(x, y, 0) == WIN ? "Anton" : "Dasha");

		out.close();
	}

	int rec(int x, int y, int rot) {
		if (x * x + y * y > D) return WIN;
		int mem = mem(x, y);
		if (mem != UNKNOWN) return mem;
		int ret = LOOSE;
		for (int dir = 0; dir < N; dir++) {
			int nx = x + dx[rot][dir];
			int ny = y + dy[rot][dir];
			int res = rec(nx, ny, rot);
			if (res == LOOSE) {
				ret = WIN;
				break;
			}
		}
		return remember(x, y, ret);
	}

	int remember(int x, int y, int val) {
		return mem[x + OFFSET][y + OFFSET] = val;
	}

	int mem(int x, int y) {
		return mem[x + OFFSET][y + OFFSET];
	}

	/***************************************************************
	 * Input
	 **************************************************************/
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class BetaRound63_Div2_D implements Runnable {

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	public static void main(String[] args) {
		new Thread(null, new BetaRound63_Div2_D(), "", 256 * (1L << 20)).start();
	}

	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			if (System.getProperty("ONLINE_JUDGE") != null) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			}
			Locale.setDefault(Locale.US);
			solve();
			in.close();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Throwable t) {
			t.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	// solution

	final int shift = 401, size = 2*shift + 1;

	int sx, sy, n, d;
	int[] vx, vy;

	boolean[][][][] dp;
	boolean[][][][] vis;

	boolean ok(int x, int y) {
		return (x - shift) * (x - shift) + (y - shift) * (y - shift) > d * d;
	}

	boolean get(int x, int y, int used1, int used2) {
		if (ok(x, y)) {
			return true;
		}
		if (vis[used1][used2][x][y]) {
			return dp[used1][used2][x][y];
		}

		boolean result = false;
		if (used1 == 0) {
			result |= !get(y, x, used2, 1);
		}
		for (int i = 0; i < n; i++) {
			result |= !get(x + vx[i], y + vy[i], used2, used1);
		}

		vis[used1][used2][x][y] = true;
		return dp[used1][used2][x][y] = result;
	}

	void solve() throws IOException {
		sx = readInt() + shift;
		sy = readInt() + shift;
		n = readInt();
		d = readInt();
		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = readInt();
			vy[i] = readInt();
		}
		// used 1, used 2, x, y
		dp = new boolean[2][2][size][size];
		vis = new boolean[2][2][size][size];
		boolean ans = get(sx, sy, 0, 0);
		out.println(ans ? "Anton" : "Dasha");
	}

}

// Don't place your source in a package
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;

// Please name your class Main
public class Main {

	//static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

    /*static int read() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
    static String readString() throws IOException {
        in.nextToken();
        return in.sval;
	}*/

	static Scanner in = new Scanner(System.in);

	public static void main (String[] args) throws java.lang.Exception {

		//InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int T=1;

		for(int t=0;t<T;t++){
			int x=Int();
			int y=Int();
			int n=Int();
			int d=Int();

			int A[][]=new int[n][2];
			for(int i=0;i<n;i++){
				int a=Int();
				int b=Int();
				A[i][0]=a;
				A[i][1]=b;
			}

			Solution sol=new Solution();
			sol.solution(A,x,y,d);
		}

		out.flush();
	}

	public static int Int(){
		return in.nextInt();
	}
	public static String Str(){
		return in.next();
	}
}

class Solution{
	//constant variable
	final int MAX=Integer.MAX_VALUE;
	final int MIN=Integer.MIN_VALUE;
	//Set<Integer>adjecent[];
	//////////////////////////////

	int d;
	boolean dp[][][][]=new boolean[500][500][2][2];
	public void solution(int A[][],int x,int y,int d){
		this.d=d;
		boolean res=dfs(A,x,y,0);
		if(res){
			msg("Anton");
		}else{
			msg("Dasha");
		}
	}

	public boolean dfs(int A[][],int tx,int ty,int turn){
		//msg("dfs "+tx+" "+ty+"  "+turn+"  ");

		if(tx*tx+ty*ty>d*d){
			return true;
		}

		if(dp[tx][ty][turn][1]){

			return dp[tx][ty][turn][0];
		}

		int next=0;
		if(turn==0)next=1;

		boolean res=false;

		for(int i=0;i<A.length;i++){
			boolean val=dfs(A,tx+A[i][0],ty+A[i][1],next);
			if(!val){
				res=true;
			}
		}
		if(tx==2&&ty==3)msg("yes");
		//msg("not lose "+tx+" "+ty+"  "+turn+"  "+res);
		dp[tx][ty][turn][0]=res;
		dp[tx][ty][turn][1]=true;

		return res;
	}

	public void swap(int A[],int l,int r){
		int t=A[l];
		A[l]=A[r];
		A[r]=t;
	}

	public long C(long fact[],int i,int j){ // C(20,3)=20!/(17!*3!)
		// take   a/b     where a=20!  b=17!*3!
		if(j>i)return 0;
		if(j==0)return 1;
		long mod=998244353;
		long a=fact[i];
		long b=((fact[i-j]%mod)*(fact[j]%mod))%mod;
		BigInteger B= BigInteger.valueOf(b);
		long binverse=B.modInverse(BigInteger.valueOf(mod)).longValue();
		return ((a)*(binverse%mod))%mod;
	}

	//map operation
	public void put(Map<Integer,Integer>map,int i){
		if(!map.containsKey(i))map.put(i,0);
		map.put(i,map.get(i)+1);
	}

	public void delete(Map<Integer,Integer>map,int i){
		map.put(i,map.get(i)-1);
		if(map.get(i)==0)map.remove(i);
	}

	/*public void tarjan(int p,int r){
		if(cut)return;
		List<Integer>childs=adjecent[r];
		dis[r]=low[r]=time;
		time++;

		//core for tarjan
		int son=0;
		for(int c:childs){
			if(ban==c||c==p)continue;
			if(dis[c]==-1){
				son++;
				tarjan(r,c);
				low[r]=Math.min(low[r],low[c]);
				if((r==root&&son>1)||(low[c]>=dis[r]&&r!=root)){
					cut=true;
					return;
				}
			}else{
				if(c!=p){
					low[r]=Math.min(low[r],dis[c]);
				}
			}
		}

	}*/

	//helper function I would use
	public void remove(Map<Integer,Integer>map,int i){
		map.put(i,map.get(i)-1);
		if(map.get(i)==0)map.remove(i);
	}

	public void ascii(String s){
		for(char c:s.toCharArray()){
			System.out.print((c-'a')+" ");
		}
		msg("");
	}

	public int flip(int i){
		if(i==0)return 1;
		else return 0;
	}

	public boolean[] primes(int n){
		boolean A[]=new boolean[n+1];
		for(int i=2;i<=n;i++){
			if(A[i]==false){
				for(int j=i+i;j<=n;j+=i){
					A[j]=true;
				}
			}
		}
		return A;
	}

	public void msg(String s){
		System.out.println(s);
	}

	public void msg1(String s){
		System.out.print(s);
	}

	public int[] kmpPre(String p){
		int pre[]=new int[p.length()];
		int l=0,r=1;
		while(r<p.length()){
			if(p.charAt(l)==p.charAt(r)){
				pre[r]=l+1;
				l++;r++;
			}else{
				if(l==0)r++;
				else l=pre[l-1];
			}
		}
		return pre;
	}

	public boolean isP(String s){
		int l=0,r=s.length()-1;
		while(l<r){
			if(s.charAt(l)!=s.charAt(r))return false;
			l++;r--;
		}
		return true;
	}

	public int find(int nums[],int x){//union find => find method
		if(nums[x]==x)return x;
		int root=find(nums,nums[x]);
		nums[x]=root;
		return root;
	}

	public int get(int A[],int i){
		if(i<0||i>=A.length)return 0;
		return A[i];
	}
	public int[] copy1(int A[]){
		int a[]=new int[A.length];
		for(int i=0;i<a.length;i++)a[i]=A[i];
		return a;
	}

	public void print1(int A[]){
		for(long i:A)System.out.print(i+" ");
		System.out.println();
	}
	public void print2(long A[][]){
		for(int i=0;i<A.length;i++){
			for(int j=0;j<A[0].length;j++){
				System.out.print(A[i][j]+" ");
			}System.out.println();
		}
	}

	public int min(int a,int b){
		return Math.min(a,b);
	}

	public int[][] matrixdp(int[][] grid) {
        if(grid.length==0)return new int[][]{};
        int res[][]=new int[grid.length][grid[0].length];
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[0].length;j++){
                res[i][j]=grid[i][j]+get(res,i-1,j)+get(res,i,j-1)-get(res,i-1,j-1);
            }
        }
        return res;
    }

    public int get(int grid[][],int i,int j){
        if(i<0||j<0||i>=grid.length||j>=grid[0].length)return 0;
        return grid[i][j];
    }

	public int[] suffixArray(String s){
		int n=s.length();
		Suffix A[]=new Suffix[n];

		for(int i=0;i<n;i++){
			A[i]=new Suffix(i,s.charAt(i)-'a',0);
		}

		for(int i=0;i<n;i++){
			if(i==n-1){
				A[i].next=-1;
			}else{
				A[i].next=A[i+1].rank;
			}
		}
		Arrays.sort(A);

		for(int len=4;len<A.length*2;len<<=1){
			int in[]=new int[A.length];
			int rank=0;
			int pre=A[0].rank;
			A[0].rank=rank;
			in[A[0].index]=0;
			for(int i=1;i<A.length;i++){//rank for the first two letter
				if(A[i].rank==pre&&A[i].next==A[i-1].next){
					pre=A[i].rank;
					A[i].rank=rank;
				}else{
					pre=A[i].rank;
					A[i].rank=++rank;
				}
				in[A[i].index]=i;
			}

			for(int i=0;i<A.length;i++){
				int next=A[i].index+len/2;
				if(next>=A.length){
					A[i].next=-1;
				}else{
					A[i].next=A[in[next]].rank;
				}
			}

			Arrays.sort(A);
		}

		int su[]=new int[A.length];
		for(int i=0;i<su.length;i++){
			su[i]=A[i].index;
		}
		return su;
	}

}

//suffix array Struct
class Suffix implements Comparable<Suffix>{
	int index;
	int rank;
	int next;
	public Suffix(int i,int rank,int next){
		this.index=i;
		this.rank=rank;
		this.next=next;
	}

	@Override
	public int compareTo(Suffix other) {
		if(this.rank==other.rank){
			return this.next-other.next;
		}
		return this.rank-other.rank;
	}

	public String toString(){
		return this.index+"   "+this.rank+"   "+this.next+"  ";
	}
}

class Wrapper implements Comparable<Wrapper>{
	int spf;int cnt;
	public Wrapper(int spf,int cnt){
		this.spf=spf;
		this.cnt=cnt;
	}

	@Override
	public int compareTo(Wrapper other) {
		return this.spf-other.spf;
	}
}

    class Node{//what the range would be for that particular node
		boolean state=false;
        int l=0,r=0;
		int ll=0,rr=0;
        public Node(boolean state){
            this.state=state;
        }
    }

	class Seg1{
			int A[];
			public Seg1(int A[]){
				this.A=A;
			}

			public void update(int left,int right,int val,int s,int e,int id){
				if(left<0||right<0||left>right)return;
				if(left==s&&right==e){

					A[id]+=val;
					return;
				}
				int mid=s+(e-s)/2; //[s,mid] [mid+1,e]

				if(left>=mid+1){
					update(left,right,val,mid+1,e,id*2+2);
				}else if(right<=mid){
					update(left,right,val,s,mid,id*2+1);
				}else{
					update(left,mid,val,s,mid,id*2+1);
					update(mid+1,right,val,mid+1,e,id*2+2);
				}
			}

			public int query(int i,int add,int s,int e,int id){

				if(s==e&&i==s){
					return A[id]+add;
				}

				int mid=s+(e-s)/2; //[s,mid] [mid+1,e]

				if(i>=mid+1){
					return query(i,A[id]+add,mid+1,e,id*2+2);
				}else{
					return query(i,A[id]+add,s,mid,id*2+1);
				}
			}
	}

	 class MaxFlow{

		  public static List<Edge>[] createGraph(int nodes) {
			List<Edge>[] graph = new List[nodes];
			for (int i = 0; i < nodes; i++)
			  graph[i] = new ArrayList<>();
			return graph;
		  }

		  public static void addEdge(List<Edge>[] graph, int s, int t, int cap) {
			graph[s].add(new Edge(t, graph[t].size(), cap));
			graph[t].add(new Edge(s, graph[s].size() - 1, 0));
		  }

		  static boolean dinicBfs(List<Edge>[] graph, int src, int dest, int[] dist) {
			Arrays.fill(dist, -1);
			dist[src] = 0;
			int[] Q = new int[graph.length];
			int sizeQ = 0;
			Q[sizeQ++] = src;
			for (int i = 0; i < sizeQ; i++) {
			  int u = Q[i];
			  for (Edge e : graph[u]) {
				if (dist[e.t] < 0 && e.f < e.cap) {
				  dist[e.t] = dist[u] + 1;
				  Q[sizeQ++] = e.t;
				}
			  }
			}
			return dist[dest] >= 0;
		  }

		  static int dinicDfs(List<Edge>[] graph, int[] ptr, int[] dist, int dest, int u, int f) {
			if (u == dest)
			  return f;
			for (; ptr[u] < graph[u].size(); ++ptr[u]) {
			  Edge e = graph[u].get(ptr[u]);
			  if (dist[e.t] == dist[u] + 1 && e.f < e.cap) {
				int df = dinicDfs(graph, ptr, dist, dest, e.t, Math.min(f, e.cap - e.f));
				if (df > 0) {
				  e.f += df;
				  graph[e.t].get(e.rev).f -= df;
				  return df;
				}
			  }
			}
			return 0;
		  }

		  public static int maxFlow(List<Edge>[] graph, int src, int dest) {
			int flow = 0;
			int[] dist = new int[graph.length];
			while (dinicBfs(graph, src, dest, dist)) {
			  int[] ptr = new int[graph.length];
			  while (true) {
				int df = dinicDfs(graph, ptr, dist, dest, src, Integer.MAX_VALUE);
				if (df == 0)
				  break;
				flow += df;
			  }
			}
			return flow;
		  }

	 }

	 	 class Edge {
			int t, rev, cap, f;

			public Edge(int t, int rev, int cap) {
			  this.t = t;
			  this.rev = rev;
			  this.cap = cap;
			}
		  }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Dot_69D
{
	static int offset = 201;

	static boolean win(int x, int y)
	{
		if (mem[x][y] != null)
			return mem[x][y];
		boolean ret = false;
		for (int i = 0; i < n; i++)
			if ((x + xs[i]) * (x + xs[i]) + (y + ys[i]) * (y + ys[i]) <= d * d)
				if (!win(x + xs[i], y + ys[i]))
				{
					ret = true;
					break;
				}
		return mem[offset + x][offset + y] = ret;

	}

	static Boolean[][] mem;
	static int n, d;
	static int[] xs, ys;

	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		int x = sc.nextInt();
		int y = sc.nextInt();
		n = sc.nextInt();
		d = sc.nextInt();
		xs = new int[n];
		ys = new int[n];
		for(int i=0;i<n;i++)
			xs[i] = sc.nextInt();
		for(int i=0;i<n;i++)
			ys[i] = sc.nextInt();
		mem = new Boolean[409][409];

		System.out.println(win(x, y) ? "Anton" : "Dasha");
	}

	static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s)
		{
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException
		{
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException
		{
			return br.readLine();
		}

		public double nextDouble() throws IOException
		{
			return Double.parseDouble(next());
		}

		public boolean ready() throws IOException
		{
			return br.ready();
		}
	}
}

import java.util.*;
import java.io.*;
import java.math.*;
public class Main
{
    static class Reader
    {
        private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
        public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
        public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
        public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
        public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
        public int i(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
        public double d() throws IOException {return Double.parseDouble(s()) ;}
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
        public int[] arr(int n){int[] ret = new int[n];for (int i = 0; i < n; i++) {ret[i] = i();}return ret;}
    }

           //       |----|       /\      |    |   -----   |
           //       |   /       /  \     |    |     |     |
           //       |--/       /----\    |----|     |     |
           //       |   \     /      \   |    |     |     |
           //       |    \   /        \  |    |   -----   -------

    static int d,n,x1,y1;
    static int arr[][];
    public static int dfs(int x,int y,int chance,int flip1,int flip2)
    {
        if(Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1))>=d)
        return 1;
        for(int i=0;i<n;i++)
        {
            if(dfs(x+arr[i][0],y+arr[i][1],chance^1,flip1,flip2)==0)
            return 1;
        }
        if(chance==0&&flip1==0)
        if(dfs(y,x,chance^1,1,flip2)==0)
        return 1;
        if(chance==1&&flip2==0)
        if(dfs(y,x,chance^1,flip1,1)==0)
        return 1;
        return 0;
    }
    public static void main(String[] args)throws IOException
    {
        PrintWriter out= new PrintWriter(System.out);
        Reader sc=new Reader();
        x1=sc.i();y1=sc.i();n=sc.i();d=sc.i();
        arr=new int[n][2];
        for(int i=0;i<n;i++)
        {
            arr[i][0]=sc.i();
            arr[i][1]=sc.i();
        }
        if(dfs(x1,y1,0,0,0)==1)
        out.println("Anton");
        else
        out.println("Dasha");
        out.flush();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class D implements Runnable {

	final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	final static String fileName = "";

	void init() throws IOException {
		if (ONLINE_JUDGE) {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		} else {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		}
	}

	public static void main(String[] args) {
		new D().run();
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws NumberFormatException, IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws NumberFormatException, IOException {
		return Long.parseLong(readString());
	}

	int[] readIntArray(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i = 0; i < size; i++) {
			arr[i] = readInt();
		}
		return arr;
	}

	static long timeIn;

	void time() {
		System.err.println("Time = " + (System.currentTimeMillis() - timeIn));
	}

	@Override
	public void run() {
		try {
			timeIn = System.currentTimeMillis();
			init();
			solve();
			out.close();
			time();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(-1);
		}
	}

	int[] vx, vy;
	int n;
	int d;
	int[][][][] dp;

	boolean isWin(int x, int y, int playerNumber, boolean hasReverseFirst, boolean hasReverseSecond) {
		if (x * x + y * y > d * d) {
			return true;
		}

		int cachedValue = dp[hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT];
		if (cachedValue == WIN) {
			return true;
		}
		if (cachedValue == LOSE) {
			return false;
		}

		boolean isLose = true;
		for (int i = 0; i < n; i++) {
			isLose &= isWin(x + vx[i], y + vy[i], 1 - playerNumber, hasReverseFirst, hasReverseSecond);
		}
		if (playerNumber == 0 && hasReverseFirst) {
			isLose &= isWin(y, x, 1 - playerNumber, false, hasReverseSecond);
		}
		if (playerNumber == 1 && hasReverseSecond) {
			isLose &= isWin(y, x, 1 - playerNumber, hasReverseFirst, false);
		}

		dp[hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = isLose ? LOSE
				: WIN;
		return !isLose;
	}

	final int MAX_ABS_SHIFT = 404;
	final int WIN = 1;
	final int LOSE = 2;

	private void solve() throws IllegalArgumentException, IOException {
		int startX = readInt();
		int startY = readInt();
		n = readInt();
		d = readInt();

		dp = new int[2][2][1000][1000];

		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = readInt();
			vy[i] = readInt();
		}

		boolean firstWin = isWin(startX, startY, 0, true, true);
		out.println(firstWin ? "Anton" : "Dasha");
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class D implements Runnable {

	final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	final static String fileName = "";

	void init() throws IOException {
		if (ONLINE_JUDGE) {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		} else {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		}
	}

	public static void main(String[] args) {
		new D().run();
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws NumberFormatException, IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws NumberFormatException, IOException {
		return Long.parseLong(readString());
	}

	int[] readIntArray(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i = 0; i < size; i++) {
			arr[i] = readInt();
		}
		return arr;
	}

	static long timeIn;

	void time() {
		System.err.println("Time = " + (System.currentTimeMillis() - timeIn));
	}

	@Override
	public void run() {
		try {
			timeIn = System.currentTimeMillis();
			init();
			solve();
			out.close();
			time();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(-1);
		}
	}

	int[] vx, vy;
	int n;
	int d;
	int[][][][] dp;

	boolean isWin(int x, int y, int playerNumber, boolean hasReverseFirst, boolean hasReverseSecond) {
		if (x * x + y * y > d * d) {
			dp[hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = WIN;
			return true;
		}

		int cachedValue = dp[hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT];
		if (cachedValue == WIN) {
			return true;
		}
		if (cachedValue == LOSE) {
			return false;
		}

		boolean isLose = true;
		for (int i = 0; i < n; i++) {
			isLose &= isWin(x + vx[i], y + vy[i], 1 - playerNumber, hasReverseFirst, hasReverseSecond);
		}
		if (playerNumber == 0 && hasReverseFirst) {
			isLose &= isWin(y, x, 1 - playerNumber, false, hasReverseSecond);
		}
		if (playerNumber == 1 && hasReverseSecond) {
			isLose &= isWin(y, x, 1 - playerNumber, hasReverseFirst, false);
		}

		dp[hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = isLose ? LOSE
				: WIN;
		return !isLose;
	}

	final int MAX_ABS_SHIFT = 200;
	final int WIN = 1;
	final int LOSE = 2;

	private void solve() throws IllegalArgumentException, IOException {
		int startX = readInt();
		int startY = readInt();
		n = readInt();
		d = readInt();

		dp = new int[2][2][1000][1000];

		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = readInt();
			vy[i] = readInt();
		}

		boolean firstWin = isWin(startX, startY, 0, true, true);
		out.println(firstWin ? "Anton" : "Dasha");
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class D implements Runnable {

	final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	final static String fileName = "";

	void init() throws IOException {
		if (ONLINE_JUDGE) {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		} else {
			if (fileName.isEmpty()) {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			} else {
				in = new BufferedReader(new FileReader(fileName + ".in"));
				out = new PrintWriter(fileName + ".out");
			}
		}
	}

	public static void main(String[] args) {
		new D().run();
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws NumberFormatException, IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws NumberFormatException, IOException {
		return Long.parseLong(readString());
	}

	int[] readIntArray(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i = 0; i < size; i++) {
			arr[i] = readInt();
		}
		return arr;
	}

	static long timeIn;

	void time() {
		System.err.println("Time = " + (System.currentTimeMillis() - timeIn));
	}

	@Override
	public void run() {
		try {
			timeIn = System.currentTimeMillis();
			init();
			solve();
			out.close();
			time();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(-1);
		}
	}

	int[] vx, vy;
	int n;
	int d;
	int[][][][] dp;

	boolean isWin(int x, int y, int playerNumber, boolean hasReverseFirst, boolean hasReverseSecond) {
		if (x * x + y * y > d * d) {
			dp[0][0][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = WIN;
			dp[0][1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = WIN;
			dp[1][0][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = WIN;
			dp[1][1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = WIN;
			return true;
		}

		int cachedValue = dp[hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT];
		if (cachedValue == WIN) {
			return true;
		}
		if (cachedValue == LOSE) {
			return false;
		}

		boolean isLose = true;
		for (int i = 0; i < n; i++) {
			isLose &= isWin(x + vx[i], y + vy[i], 1 - playerNumber, hasReverseFirst, hasReverseSecond);
		}
		if (playerNumber == 0 && hasReverseFirst) {
			isLose &= isWin(y, x, 1 - playerNumber, false, hasReverseSecond);
		}
		if (playerNumber == 1 && hasReverseSecond) {
			isLose &= isWin(y, x, 1 - playerNumber, hasReverseFirst, false);
		}

		dp[hasReverseFirst ? 0 : 1][hasReverseSecond ? 0 : 1][x + MAX_ABS_SHIFT][y + MAX_ABS_SHIFT] = isLose ? LOSE
				: WIN;
		return !isLose;
	}

	final int MAX_ABS_SHIFT = 200;
	final int WIN = 1;
	final int LOSE = 2;

	private void solve() throws IllegalArgumentException, IOException {
		int startX = readInt();
		int startY = readInt();
		n = readInt();
		d = readInt();

		dp = new int[2][2][1000][1000];

		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = readInt();
			vy[i] = readInt();
		}

		boolean firstWin = isWin(startX, startY, 0, true, true);
		out.println(firstWin ? "Anton" : "Dasha");
	}
}

import java.util.*;

public class d {
	public static int n,d;
	public static int[] vecx, vecy;
	public static int[][][][][] memo;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int x = in.nextInt();
		int y = in.nextInt();
		n = in.nextInt();
		d = in.nextInt();
		vecx = new int[n];
		vecy = new int[n];
		for(int i=0; i<n; i++) {
			vecx[i] = in.nextInt();
			vecy[i] = in.nextInt();
		}
		memo = new int[410][410][2][2][2];
		if(win(x,y,0,0,0)==-1)
			System.out.println("Anton");
		else
			System.out.println("Dasha");
	}
	public static int win(int x, int y, int p1flip, int p2flip, int player) {
		if(x*x+y*y>d*d)
			return -1;
		if(memo[x+202][y+202][p1flip][p2flip][player] != 0)
			return memo[x+202][y+202][p1flip][p2flip][player];
		boolean winner = false;
		if((player==0&&p1flip==0)||(player==1&&p2flip==0)) {
			if(win(y,x,player==0?1:p1flip,player==1?1:p2flip,1-player)==-1)
				winner = true;
		}
		for(int i=0; i<n; i++) {
			if(win(x+vecx[i],y+vecy[i],p1flip,p2flip,1-player)==-1)
				winner = true;
		}
		int res = winner?1:-1;
		return memo[x+202][y+202][p1flip][p2flip][player] = res;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread() {
			public void run() {
				try {
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}.start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int d, n;
	int vect[][];

	boolean used[][][];

	int MAXX = 400;
	int MAXY = 400;

	boolean dfs(boolean who, int x, int y){
		used[x+MAXX][y+MAXY][who? 1: 0] = true;
		if(x*x + y*y > d*d)
			return !who;		//anton on his turn already lost

		boolean ret;

		if(!who){	//anton
			ret = false;
			for(int i = 0; i < n; i++)
				if(!used[x + MAXX + vect[i][0]][y + MAXY + vect[i][1]][who? 1: 0])
					ret |= dfs(!who, x + vect[i][0], y + vect[i][1]);
		}
		else{
			ret = true;
			boolean ok = false;
			for(int i = 0; i < n; i++)
				if(!used[x+MAXX + vect[i][0] ][y+MAXY + vect[i][1] ][who? 1: 0]){
					ok = true;
					ret &= dfs(!who, x + vect[i][0], y + vect[i][1]);
				}
			ret &= ok;		//maybe no path from here
		}
		return ret;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();

		vect = new int[n][2];
		used = new boolean[MAXX * 2][MAXY * 2][2];

		for(int i = 0; i < n; i++){
			vect[i][0] = nextInt();
			vect[i][1] = nextInt();
		}

		boolean ans = dfs(false, x, y);
		if(ans)
			out.println("Anton");
		else
			out.println("Dasha");
		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread() {
			public void run() {
				try {
					new Main().run();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}.start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int d, n;
	int vect[][];

	boolean used[][][];

	int MAXX = 400;
	int MAXY = 400;

	boolean dfs(boolean who, int x, int y){
		used[x+MAXX][y+MAXY][who? 1: 0] = true;
		if(x*x + y*y > d*d)
			return !who;		//false for anton

		boolean ret;

		if(!who){	//anton
			ret = false;
			for(int i = 0; i < n; i++)
				if(!used[x + MAXX + vect[i][0]][y + MAXY + vect[i][1]][who? 1: 0])
					ret |= dfs(!who, x + vect[i][0], y + vect[i][1]);
		}
		else{
			ret = true;
			for(int i = 0; i < n; i++)
				if(!used[x+MAXX + vect[i][0] ][y+MAXY + vect[i][1] ][who? 1: 0])
					ret &= dfs(!who, x + vect[i][0], y + vect[i][1]);
		}
		return ret;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();

		vect = new int[n][2];
		used = new boolean[MAXX * 2][MAXY * 2][2];

		for(int i = 0; i < n; i++){
			vect[i][0] = nextInt();
			vect[i][1] = nextInt();
		}

		boolean ans = dfs(false, x, y);
		if(ans)
			out.println("Anton");
		else
			out.println("Dasha");
		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.util.Scanner;

public class D {

    static boolean[][]f, calculated;
    static int[]x,y;
    static int d, n;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x0 = sc.nextInt()+210;
        int y0 = sc.nextInt()+210;
        n = sc.nextInt();
        d = sc.nextInt();
        x = new int[n+1];
        y = new int[n+1];
        for (int i = 1; i <= n; i++) {
            x[i] = sc.nextInt();
            y[i] = sc.nextInt();
        }
        f = new boolean[420][420];
        calculated = new boolean[420][420];
        dfs(y0, x0);
        if (f[y0][x0])
            System.out.println("Anton");
        else
            System.out.println("Dasha");
    }
    private static boolean dfs(int y0, int x0) {
        if (calculated[y0][x0])
            return f[y0][x0];
        calculated[y0][x0] = true;
        if ((x0-210)*(x0-210)+(y0-210)*(y0-210) > d*d)
            return true;
        for (int i = 1; i <= n; i++) {
            if (!dfs(y0+y[i], x0+x[i])){
                return f[y0][x0] = true;
            }
        }
        return f[y0][x0] = false;
    }
}

import java.io.*;
import java.util.*;

public class D {

    int n, d;
    int w[][][][];
    int dx[];
    int dy[];

    void solve() throws IOException {
        in("__std"); out("__std");

        int x = readInt();
        int y = readInt();
        n = readInt();
        d = readInt();

        dx = new int[n];
        dy = new int[n];

        for (int i = 0; i < n; ++i) {
            dx[i] = readInt();
            dy[i] = readInt();
        }

        w = new int[2 * d + 2][2 * d + 2][2][4];

        println(win(x, y, 0, 0) ? "Anton" : "Dasha");

        exit();
    }

    boolean win(int x, int y, int t, int m) {
        int sx = x + d;
        int sy = y + d;
        if (w[sx][sy][t][m] == 0) {
            w[sx][sy][t][m] = 2;
            for (int i = 0; i < n; ++i) {
                int xx = x + dx[i];
                int yy = y + dy[i];
                if (xx * xx + yy * yy <= d * d && !win(xx, yy, 1 - t, m)) {
                    w[sx][sy][t][m] = 1;
                    break;
                }
            }
            if ((m & (1 << t)) == 0 && !win(y, x, 1 - t, m & (1 << t))) {
                w[sx][sy][t][m] = 1;
            }
        }
        return w[sx][sy][t][m] == 1;
    }

    void in(String name) throws IOException {
        if (name.equals("__std")) {
            in = new BufferedReader(new InputStreamReader(System.in));
        } else {
            in = new BufferedReader(new FileReader(name));
        }
    }

    void out(String name) throws IOException {
        if (name.equals("__std")) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(name);
        }
    }

    void exit() {
        out.close();
        System.exit(0);
    }

    int readInt() throws IOException {
        return Integer.parseInt(readToken());
    }

    long readLong() throws IOException {
        return Long.parseLong(readToken());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readToken());
    }

    String readLine() throws IOException {
        st = null;
        return in.readLine();
    }

    String readToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    boolean eof() throws IOException {
        return !in.ready();
    }

    void print(String format, Object ... args) {
        out.println(new Formatter().format(format, args));
    }

    void println(String format, Object ... args) {
        out.println(new Formatter().format(format, args));
    }

    void print(Object value) {
        out.print(value);
    }

    void println(Object value) {
        out.println(value);
    }

    void println() {
        out.println();
    }

    StringTokenizer st;

    BufferedReader in;
    PrintWriter out;

    public static void main(String[] args) throws IOException {
        new D().solve();
    }
}

import java.io.*;
import java.util.*;

public class D{

    void solve()throws Exception
    {

    }

	BufferedReader reader;
	PrintWriter writer;
	StringTokenizer stk;
	void run()throws Exception
	{
		reader=new BufferedReader(new InputStreamReader(System.in));
		stk=null;
		writer=new PrintWriter(System.out);
		solve();
		//reader.close();
		//writer.close();
	}
	int nextInt()throws Exception
	{
		return Integer.parseInt(nextToken());
	}
	long nextLong()throws Exception
	{
		return Long.parseLong(nextToken());
	}
	double nextDouble()throws Exception
	{
		return Double.parseDouble(nextToken());
	}
	String nextString()throws Exception
	{
		return nextToken();
	}
	String nextLine()throws Exception
	{
		return reader.readLine();
	}
	String nextToken()throws Exception
	{
		if(stk==null || !stk.hasMoreTokens())
		{
			stk=new StringTokenizer(nextLine());
			return nextToken();
		}
		return stk.nextToken();
	}

	public static void main(String[]a) throws Exception
	{
		new D().run();

	}

}

import java.util.Scanner;

public class D_Dot {

    /**
     * @param args
     */

    static int ix, iy, n, d;
    static int[][][] memo;
    static int[] vx;
    static int[] vy;

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        ix = sc.nextInt();
        iy = sc.nextInt();
        n = sc.nextInt();
        d = sc.nextInt();

        memo = new int[401][401][2];
        vx = new int[n];
        vy = new int[n];

        for (int i = 0; i < n; i++) {
            vx[i] = sc.nextInt();
            vy[i] = sc.nextInt();
        }

        boolean result = foo(ix, iy, true);
        System.out.println(result ? "Anton" : "Dasha");

    }

    private static boolean foo(int x, int y, boolean turn){

        int key = (turn ? 1 : 0);

        if(memo[x+200][y+200][key] != 0) return memo[x+200][y+200][key] == (turn ? 1 : -1);

        boolean result = false;

        for (int i = 0; i < n; i++) {
            int nx = x+vx[i];
            int ny = y+vy[i];
            if(nx * nx + ny * ny <= d * d){
                if(! foo(nx, ny, !turn)){
                    result = true;
                    break;
                }
            }
        }

        /*
        if(!result){
            if((turn && !ause) || (!turn && !duse)){
                int nx = y;
                int ny = x;

                if(turn) ause = true;
                else duse = true;

                if(! foo(nx, ny, !turn, ause, duse)){
                    result = true;
                }
            }
        }
        */

        memo[x+200][y+200][key] = result ? 1 : -1;
        return result;
    }

}

import java.util.Scanner;

public class D_Dot {

    /**
     * @param args
     */

    static int ix, iy, n, d;
    static int[][][] memo;
    static int[] vx;
    static int[] vy;

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        ix = sc.nextInt();
        iy = sc.nextInt();
        n = sc.nextInt();
        d = sc.nextInt();

        memo = new int[401][401][8];
        vx = new int[n];
        vy = new int[n];

        for (int i = 0; i < n; i++) {
            vx[i] = sc.nextInt();
            vy[i] = sc.nextInt();
        }

        boolean result = foo(ix, iy, true, false, false);
        System.out.println(result ? "Anton" : "Dasha");

    }

    private static boolean foo(int x, int y, boolean turn, boolean ause, boolean duse){

        int key = (turn ? 1 : 0);
        key = (key << 1) | (ause ? 1 : 0);
        key = (key << 1) | (duse ? 1 : 0);

        int me = turn ? 1 : -1;

        if(memo[x+200][y+200][key] != 0) return memo[x+200][y+200][key] == me ? true : false;

        boolean result = false;

        for (int i = 0; i < n; i++) {
            int nx = x+vx[i];
            int ny = y+vy[i];
            if(nx * nx + ny * ny <= d * d){
                if(! foo(nx, ny, !turn, ause, duse)){
                    result = true;
                    break;
                }
            }
        }

        if(!result){
            if((turn && !ause) || (!turn && !duse)){
                int nx = y;
                int ny = x;

                if(turn) ause = true;
                else duse = true;

                if(! foo(nx, ny, !turn, ause, duse)){
                    result = true;
                }
            }
        }

        memo[x+200][y+200][key] = result ? 1 : -1;
        return result;
    }

}

import java.util.Scanner;

public class D_Dot {

    /**
     * @param args
     */

    static int ix, iy, n, d;
    static int[][][] memo;
    static int[] vx;
    static int[] vy;

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        ix = sc.nextInt();
        iy = sc.nextInt();
        n = sc.nextInt();
        d = sc.nextInt();

        memo = new int[401][401][8];
        vx = new int[n];
        vy = new int[n];

        for (int i = 0; i < n; i++) {
            vx[i] = sc.nextInt();
            vy[i] = sc.nextInt();
        }

        boolean result = foo(ix, iy, true, false, false);
        System.out.println(result ? "Anton" : "Dasha");

    }

    private static boolean foo(int x, int y, boolean turn, boolean ause, boolean duse){

        int key = (turn ? 1 : 0);
        key = (key << 1) | (ause ? 1 : 0);
        key = (key << 1) | (duse ? 1 : 0);

        if(memo[x+200][y+200][key] != 0) return memo[x+200][y+200][key] == (turn ? 1 : -1);

        boolean result = false;

        for (int i = 0; i < n; i++) {
            int nx = x+vx[i];
            int ny = y+vy[i];
            if(nx * nx + ny * ny <= d * d){
                if(! foo(nx, ny, !turn, ause, duse)){
                    result = true;
                    break;
                }
            }
        }

        /*
        if(!result){
            if((turn && !ause) || (!turn && !duse)){
                int nx = y;
                int ny = x;

                if(turn) ause = true;
                else duse = true;

                if(! foo(nx, ny, !turn, ause, duse)){
                    result = true;
                }
            }
        }
        */

        memo[x+200][y+200][key] = result ? 1 : -1;
        return result;
    }

}

import java.util.Scanner;

public class D_Dot {

    /**
     * @param args
     */

    static int ix, iy, n, d;
    static int[][][] memo;
    static int[] vx;
    static int[] vy;

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Scanner sc = new Scanner(System.in);
        ix = sc.nextInt();
        iy = sc.nextInt();
        n = sc.nextInt();
        d = sc.nextInt();

        memo = new int[401][401][8];
        vx = new int[n];
        vy = new int[n];

        for (int i = 0; i < n; i++) {
            vx[i] = sc.nextInt();
            vy[i] = sc.nextInt();
        }

        boolean result = foo(ix, iy, true, false, false);
        System.out.println(result ? "Anton" : "Dasha");

    }

    private static boolean foo(int x, int y, boolean turn, boolean ause, boolean duse){

        int key = (turn ? 1 : 0);
        key = (key << 1) | (ause ? 1 : 0);
        key = (key << 1) | (duse ? 1 : 0);

        if(memo[x+200][y+200][key] != 0) return memo[x+200][y+200][key] == (turn ? 1 : -1);

        boolean result = false;

        for (int i = 0; i < n; i++) {
            int nx = x+vx[i];
            int ny = y+vy[i];
            if(nx * nx + ny * ny <= d * d){
                if(! foo(nx, ny, !turn, ause, duse)){
                    result = true;
                    break;
                }
            }
        }

        if(!result){
            if((turn && !ause) || (!turn && !duse)){
                int nx = y;
                int ny = x;

                if(turn) ause = true;
                else duse = true;

                if(! foo(nx, ny, !turn, ause, duse)){
                    result = true;
                }
            }
        }

        memo[x+200][y+200][key] = result ? 1 : -1;
        return result;
    }

}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int m[][][][][];
	int n,d;
	int dx[];
	int dy[];
	boolean test(int x, int y,int f0, int f1, int num){
		if( x < 0 || y < 0 || x > 2 * d || y > 2 * d)	//��� ���������� +
			return true;
		if(m[x][y][f0][f1][num] != 0)
			return m[x][y][f0][f1][num] == 1;

		if(num == 0 && f0 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + 2 * de, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - 2 * de, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}

		if(num == 1 && f1 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}
		for(int i = 0; i < n; i++){
			if(!test(x + dx[i], y + dy[i], f0, f1, num)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
		}
		m[x][y][f0][f1][num] = -1;
		return false;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		m = new int[2 * d + 1][2 * d + 1][2][2][2];
		for(int i = 0; i < n; i++){
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		if(test(x + d,y + d,1,1,0))
			out.println("Dasha");
		else
			out.println("Anton");

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int m[][][][][];
	int n,d;
	int dx[];
	int dy[];
	boolean test(int x, int y,int f0, int f1, int num){
		if( x < 0 || y < 0 || x > 2 * d || y > 2 * d)	//��� ���������� +
			return true;
		if(m[x][y][f0][f1][num] != 0)
			return m[x][y][f0][f1][num] == 1;

		if(num == 0 && f0 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + 2 * de, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - 2 * de, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
			if(!test(x + 1, y, 0, f1, 1)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
			if(!test(x - 1, y, 0, f1, 1)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
		}

		if(num == 1 && f1 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}
		for(int i = 0; i < n; i++){
			if(!test(x + dx[i], y + dy[i], f0, f1, num)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
		}
		m[x][y][f0][f1][num] = -1;
		return false;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		m = new int[2 * d + 1][2 * d + 1][2][2][2];
		for(int i = 0; i < n; i++){
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		if(test(x + d,y + d,1,1,0))
			out.println("Dasha");
		else
			out.println("Anton");

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int m[][][][][];
	int n,d;
	int dx[];
	int dy[];
	boolean test(int x, int y,int f0, int f1, int num){
		if( x < 0 || y < 0 || x > 2 * d || y > 2 * d)	//��� ���������� +
			return true;
		if(m[x][y][f0][f1][num] != 0)
			return m[x][y][f0][f1][num] == 1;

		if(num == 0 && f0 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + de, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - de, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}

		if(num == 1 && f1 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}
		for(int i = 0; i < n; i++){
			if(!test(x + dx[i], y + dy[i], f0, f1, num)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
		}
		m[x][y][f0][f1][num] = -1;
		return false;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		m = new int[2 * d + 1][2 * d + 1][2][2][2];
		for(int i = 0; i < n; i++){
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		if(test(x + d,y + d,1,1,0))
			out.println("Dasha");
		else
			out.println("Anton");

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int m[][][][][];
	int n,d;
	int dx[];
	int dy[];
	boolean test(int x, int y,int f0, int f1, int num){
		if( x < 0 || y < 0 || x > 2 * d || y > 2 * d)	//��� ���������� +
			return true;
		if(m[x][y][f0][f1][num] != 0)
			return m[x][y][f0][f1][num] == 1;

//		if(num == 0 && f0 == 1){
//			for(int de = 0; de <= d; de ++){
//				if(!test(x + 2 * de + 1, y, 0, f1, 1)){
//					m[x][y][f0][f1][num] = 1;
//					return true;
//				}
//				if(!test(x - 2 * de - 1, y, 0, f1, 1)){
//					m[x][y][f0][f1][num] = 1;
//					return true;
//				}
//			}
//		}
//		if(num == 1 && f1 == 1){
//			for(int de = 0; de <= d; de ++){
//				if(!test(x + 2 * de + 1, y, f0, 0, 0)){
//					m[x][y][f0][f1][num] = 1;
//					return true;
//				}
//				if(!test(x - 2 * de - 1, y, f0, 0, 0)){
//					m[x][y][f0][f1][num] = 1;
//					return true;
//				}
//			}
//		}
		for(int i = 0; i < n; i++){
			if(!test(x + dx[i], y + dy[i], f0, f1, num)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
		}
		m[x][y][f0][f1][num] = -1;
		return false;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		m = new int[2 * d + 1][2 * d + 1][2][2][2];
		for(int i = 0; i < n; i++){
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		if(test(x + d,y + d,1,1,0))
			out.println("Dasha");
		else
			out.println("Anton");

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int m[][][][][];
	int n,d;
	int dx[];
	int dy[];
	boolean test(int x, int y,int f0, int f1, int num){
		if( x < 0 || y < 0 || x > 2 * d || y > 2 * d)	//��� ���������� +
			return true;
		if(m[x][y][f0][f1][num] != 0)
			return m[x][y][f0][f1][num] == 1;

		if(num == 0 && f0 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + 2 * de + 1, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - 2 * de - 1, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}
		if(num == 1 && f1 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + 2 * de + 1, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - 2 * de - 1, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}
		for(int i = 0; i < n; i++){
			if(!test(x + dx[i], y + dy[i], f0, f1, num)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
		}
		m[x][y][f0][f1][num] = -1;
		return false;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		m = new int[2 * d + 1][2 * d + 1][2][2][2];
		for(int i = 0; i < n; i++){
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		if(test(x + d,y + d,1,1,0))
			out.println("Dasha");
		else
			out.println("Anton");

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	int m[][][][][];
	int n,d;
	int dx[];
	int dy[];
	boolean test(int x, int y,int f0, int f1, int num){
		if( x < 0 || y < 0 || x > 2 * d || y > 2 * d)	//��� ���������� +
			return true;
		if(m[x][y][f0][f1][num] != 0)
			return m[x][y][f0][f1][num] == 1;

		if(num == 0 && f0 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + 2 * de + 1, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - 2 * de - 1, y, 0, f1, 1)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}
		if(num == 1 && f1 == 1){
			for(int de = 0; de <= d; de ++){
				if(!test(x + de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
				if(!test(x - de, y, f0, 0, 0)){
					m[x][y][f0][f1][num] = 1;
					return true;
				}
			}
		}
		for(int i = 0; i < n; i++){
			if(!test(x + dx[i], y + dy[i], f0, f1, num)){
				m[x][y][f0][f1][num] = 1;
				return true;
			}
		}
		m[x][y][f0][f1][num] = -1;
		return false;
	}

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);

		int x = nextInt();
		int y = nextInt();
		n = nextInt();
		d = nextInt();
		dx = new int[n];
		dy = new int[n];
		m = new int[2 * d + 1][2 * d + 1][2][2][2];
		for(int i = 0; i < n; i++){
			dx[i] = nextInt();
			dy[i] = nextInt();
		}
		if(test(x + d,y + d,1,1,0))
			out.println("Dasha");
		else
			out.println("Anton");

		in.close();
		out.close();
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    final static int Base = 202;

    static class Vector {
        int x, y;

        Vector add(Vector o) {
            Vector ret = new Vector();
            ret.x = x + o.x;
            ret.y = y + o.y;
            return ret;
        }
    }

    static Vector[] vectors;
    static int dist;
    static int[][] map;

    static boolean isAway(Vector o) {
        double dx = o.x;
        double dy = o.y;
        if (Math.sqrt(dx * dx + dy * dy) > dist) {
            return true;
        }
        else {
            return false;
        }
    }

    static int getState(Vector cur) {
        if (map[cur.x][cur.y] != -1) {
            return map[cur.x][cur.y];
        }
        else {
            if (isAway(cur)) {
                return map[cur.x][cur.y] = 1;
            }
            map[cur.x][cur.y] = -1;
            for (int i = 0; i < vectors.length; i ++) {
                Vector tmp = cur.add(vectors[i]);
                int state = getState(tmp);
                if (state == -1) {
                    map[cur.x][cur.y] = 1;
                    break;
                }
            }
            return map[cur.x][cur.y];
        }
    }

    public static void main(String[] args) {
        Scanner cin = new Scanner (System.in);
        map = new int[700][700];
        for (int i = 0; i < 700; i ++) {
            Arrays.fill(map[i], -1);
        }

        Vector start = new Vector();
        start.x = cin.nextInt() + Base;
        start.y = cin.nextInt() + Base;
        int n = cin.nextInt();
        dist = cin.nextInt();

        vectors = new Vector[n];
        for (int i = 0; i < n; i ++) {
            vectors[i] = new Vector();
            vectors[i].x = cin.nextInt();
            vectors[i].y = cin.nextInt();
        }

        if (getState(start) == 1) {
            System.out.println("Anton");
        }
        else {
            System.out.println("Dasha");
        }
    }

}

import java.io.*;
import java.util.*;

public class Main {
//	static Scanner in;
	static PrintWriter out;
	static StreamTokenizer in; static int next() throws Exception {in.nextToken(); return (int) in.nval;}

	public static void main(String[] args) throws Exception {
//		in = new Scanner(System.in);
		out = new PrintWriter(System.out);
		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));

		int xx = next();
		int yy = next();
		int n = next();
		int d = next();

		int m = 405;
		boolean[][] win = new boolean[2*m][2*m];

		int[] x = new int[n];
		int[] y = new int[n];
		for (int i = 0; i < n; i++) {
			x[i] = next(); y[i] = next();
		}

		for (int i = m - 1; i >= 0; i--)
			for (int j = m - 1; j >= 0; j--) {
				if ((i - 200)*(i - 200) + (j - 200)*(j - 200) <= d*d) {
					for (int t = 0; t < n; t++) win[i][j] |= !win[i + x[t]][j + y[t]];
				} else win[i][j] = true;
			}

		out.println(win[200 + xx][200 + yy] ? "Anton" : "Dasha");

		out.close();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
    static int n;
    static int d;
    static int[] X;
    static int[] Y;
    static int[][][][] DP = new int[401][401][2][4];
    static int startX;
    static int startY;

    public static int get(int x, int y, int turn, int ref) {
        int dx = x - startX;
        int dy = y - startY;
        if (Math.sqrt(dx * dx + dy * dy) > d)
            return turn;
        if (DP[x + 200][y + 200][turn][ref] != -1)
            return DP[x + 200][y + 200][turn][ref];
        DP[x + 200][y + 200][turn][ref] = 1 - turn;
        for (int i = 0; i < n; i++) {
            if (X[i] == x && Y[i] == y)
                continue;
            int temp = get(x + X[i], y + Y[i], 1 - turn, ref);
            if (temp == turn)
                return DP[x + 200][y + 200][turn][ref] = turn;

        }
        if ((ref & (1 << turn)) == 0)
            return DP[x + 200][y + 200][turn][ref] = get(y, x, 1 - turn, ref
                    | (1 << turn));
        return DP[x + 200][y + 200][turn][ref];
    }

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] S = in.readLine().split(" ");
        startX = Integer.parseInt(S[0]);
        startY = Integer.parseInt(S[1]);
        n = Integer.parseInt(S[2]);
        d = Integer.parseInt(S[3]);
        X = new int[n];
        Y = new int[n];
        for (int i = 0; i < n; i++) {
            S = in.readLine().split(" ");
            X[i] = Integer.parseInt(S[0]);
            Y[i] = Integer.parseInt(S[1]);
        }
        for (int i = 0; i < 401; i++)
            for (int j = 0; j < 401; j++)
                for (int k = 0; k < 2; k++)
                    Arrays.fill(DP[i][j][k], -1);
        int ans = get(startX, startY, 0, 0);
        if (ans == 0)
            System.out.println("Anton");
        else
            System.out.println("Dasha");
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.HashMap;
import java.util.TreeSet;

public class Main {
	private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(
			new InputStreamReader(System.in)));
	private static PrintWriter out = new PrintWriter(System.out);

	private static int nextInt() throws Exception {
		in.nextToken();
		return (int) in.nval;
	}

	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}

	public static void main(String[] args) throws Exception {
		int x = nextInt(), y = nextInt();
		int n = nextInt();
		d = nextInt();
		v = new int[n][];
		for (int i = 0; i < n; i++) {
			v[i] = new int[] { nextInt(), nextInt() };
		}
		dp = new int[430][430][2][2];
		out.println(f(x, y, 1, 1) == 1 ? "Anton" : "Dasha");
		out.flush();
	}

	private static int[][] v;
	private static int[][][][] dp;
	private static int d;

	private static double EPS = 1e-6;

	private static final int offset = 210;

	private static int f(int x, int y, int cani, int cano) { //1 - I win, 2 - I lose
		if (Math.sqrt(x*x + y*y) > d + EPS) {
			return 1;
		}
		int X = x + offset, Y = y + offset;
		if (dp[X][Y][cani][cano] > 0) {
			return dp[X][Y][cani][cano];
		}

		for (int[] vector : v) {
			if (f(x + vector[0], y + vector[1], cano, cani) == 2) {
				return dp[X][Y][cani][cano] = 1;
			}
		}

		if (cani == 1) {
			cani = 0;
			if (f(y, x, cano, cani) == 2) {
				return dp[X][Y][cani][cano] = 1;
			}
		}

		return dp[X][Y][cani][cano] = 2;
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.HashMap;
import java.util.TreeSet;

public class Main {
	private static StreamTokenizer in = new StreamTokenizer(new BufferedReader(
			new InputStreamReader(System.in)));
	private static PrintWriter out = new PrintWriter(System.out);

	private static int nextInt() throws Exception {
		in.nextToken();
		return (int) in.nval;
	}

	private static String nextString() throws Exception {
		in.nextToken();
		return in.sval;
	}

	public static void main(String[] args) throws Exception {
		int x = nextInt(), y = nextInt();
		int n = nextInt();
		d = nextInt();
		v = new int[n][];
		for (int i = 0; i < n; i++) {
			v[i] = new int[] { nextInt(), nextInt() };
		}
		dp = new int[430][430][2][2];
		out.println(f(x, y, 1, 1) == 1 ? "Anton" : "Dasha");
		out.flush();
	}

	private static int[][] v;
	private static int[][][][] dp;
	private static int d;

	private static final int offset = 210;

	private static int f(int x, int y, int cani, int cano) { //1 - I win, 2 - I lose
		if (Math.sqrt(x*x + y*y) > d) {
			return 1;
		}
		int X = x + offset, Y = y + offset;
		if (dp[X][Y][cani][cano] > 0) {
			return dp[X][Y][cani][cano];
		}

		for (int[] vector : v) {
			if (f(x + vector[0], y + vector[1], cano, cani) == 2) {
				return dp[X][Y][cani][cano] = 1;
			}
		}

		if (cani == 1) {
			cani = 0;
			if (f(y, x, cano, cani) == 2) {
				return dp[X][Y][cani][cano] = 1;
			}
		}

		return dp[X][Y][cani][cano] = 2;
	}
}

import java.util.Arrays;
import java.util.Scanner;

public class D {
    static int[][][][][] dp;
    static int[] xs;
    static int[] ys;
    static int end,offx,offy;
    public static int solve(int curx,int cury,int turn,int hasa,int hasb) {
        double d=(curx-offx)*(curx-offx)+(cury-offy)*(cury-offy);
        if(d>end) {
            //System.out.println(curx+" "+cury+" "+turn+" "+hasa+" "+hasb);
            if(turn==0) return 1000;       //dahsa wins
            else return -1000;              //anton wins
        }
        if(dp[curx][cury][turn][hasa][hasb]!=-1) return dp[curx][cury][turn][hasa][hasb];
        if(turn ==0) {
            int min=100000;
            for(int i=0;i<xs.length;i++) {
                min=Math.min(min,solve(curx+xs[i],cury+ys[i],(turn+1)%2,hasa,hasb));
            }
            if(hasa==1) {
                min=Math.min(min,solve(cury,curx,(turn+1)%2,hasa-1,hasb));
            }
            return dp[curx][cury][turn][hasa][hasb]=min;
        }
        else {
            int max=-100000;
            for(int i=0;i<xs.length;i++) {
                max=Math.max(max,solve(curx+xs[i],cury+ys[i],(turn+1)%2,hasa,hasb));
            }
            if(hasb==1) {
                max=Math.max(max,solve(cury,curx,(turn+1)%2,hasa,hasb-1));
            }
            return dp[curx][cury][turn][hasa][hasb]=max;
        }
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int x=sc.nextInt();
        int y=sc.nextInt();
        int c=sc.nextInt();
        end=sc.nextInt();
        end*=end;
        xs=new int[c];
        ys=new int[c];
        for(int i=0;i<xs.length;i++) {
            xs[i]=sc.nextInt();
            ys[i]=sc.nextInt();
        }
        offx=0;offy=0;
        if(x<0) offx=-1*x;
        if(y<0) offy=-1*y;
        dp=new int[401][401][2][2][2];
        for(int i=0;i<401;i++)
            for(int j=0;j<401;j++)
                for(int k=0;k<2;k++)
                    for(int  u=0;u<2;u++)
                        Arrays.fill(dp[i][j][k][u],-1);
        int res=solve(x+offx,y+offx,0,1,1);
        if(res==1000) System.out.println("Anton");
        else System.out.println("Dasha");
    }
}

import java.awt.Point;
import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class ProblemD_63 {

    final boolean ONLINE_JUDGE=System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok=new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in=new BufferedReader(new InputStreamReader(System.in));
            out =new PrintWriter(System.out);
        }
        else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok=new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemD_63().run();
    }

    public void run(){
        try{
            long t1=System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2=System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    Point[] v;
    int d;
    int n;
    int[][][] used;

    void solve() throws IOException{
        int x0 = readInt();
        int y0 = readInt();
        n = readInt();
        d = readInt();
        v = new Point[n];
        used = new int[4][600][600];
        for (int i = 0; i < n; i++){
            v[i] = new Point(readInt(), readInt());
        }
        if (dfs(1, x0, y0, false, false) == 1){
            out.print("Dasha");
        }else{
            out.print("Anton");
        }
    }

    double d(int x, int y){
        return sqrt(x*x + y*y);
    }

    int ind(boolean f1, boolean f2){
        return f1? f2? 3: 2: f2? 1: 0;
    }

    int dfs(int num, int x, int y, boolean f1, boolean f2){
        int ind = ind(f1, f2);
        if (used[ind][x+200][y+200] != 0){
            return used[ind][x+200][y+200];
        }
        if (d(x, y) >= d){
            return used[ind][x+200][y+200] = -1;
        }
        if (num == 1 && !f1){
            if (dfs(1 - num, y, x, !f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        if (num == 0 && !f2){
            if (dfs(1 - num, y, x, f1, !f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        for (int i = 0; i < n; i++){
            if (dfs(1 - num, x + v[i].x, y + v[i].y, f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        return used[ind][x+200][y+200] = 1;
    }
}

import java.awt.Point;
import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class ProblemD_63 {

    final boolean ONLINE_JUDGE=System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok=new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in=new BufferedReader(new InputStreamReader(System.in));
            out =new PrintWriter(System.out);
        }
        else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok=new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemD_63().run();
    }

    public void run(){
        try{
            long t1=System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2=System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    int n;
    int d;
    Point[] v;
    int[][][] used;

    void solve() throws IOException{
        int x0 = readInt();
        int y0 = readInt();
        n = readInt();
        d = readInt();
        v = new Point[n];
        used = new int[4][600][600];
        for (int i = 0; i < n; i++){
            v[i] = new Point(readInt(), readInt());
        }
        if (dfs(1, x0, y0, false, false) == 1){
            out.print("Dasha");
        }else{
            out.print("Anton");
        }
    }

    double d(int x, int y){
        return sqrt(x*x + y*y);
    }

    int ind(boolean f1, boolean f2){
        return f1? f2? 3: 2: f2? 1: 0;
    }

    int dfs(int num, int x, int y, boolean f1, boolean f2){
        int ind = ind(f1, f2);
        if (used[ind][x+200][y+200] != 0){
            return used[ind][x+200][y+200];
        }
        if (d(x, y) > d){
            return used[ind][x+200][y+200] = -1;
        }
        if (num == 1 && !f1){
            if (dfs(1 - num, y, x, !f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        if (num == 0 && !f2){
            if (dfs(1 - num, y, x, f1, !f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        for (int i = 0; i < n; i++){
            if (dfs(1 - num, x + v[i].x, y + v[i].y, f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        return used[ind][x+200][y+200] = 1;
    }
}

import java.awt.Point;
import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class ProblemD_63 {

    final boolean ONLINE_JUDGE=System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok=new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in=new BufferedReader(new InputStreamReader(System.in));
            out =new PrintWriter(System.out);
        }
        else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok=new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemD_63().run();
    }

    public void run(){
        try{
            long t1=System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2=System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    Point[] v;
    int d;
    int n;

    void solve() throws IOException{
        int x0 = readInt();
        int y0 = readInt();
        n = readInt();
        d = readInt();
        v = new Point[n];
        for (int i = 0; i < n; i++){
            v[i] = new Point(readInt(), readInt());
        }
        if (dfs(0, x0, y0, false, false)){
            out.print("Anton");
        }else{
            out.print("Dasha");
        }
    }

    double d(int x, int y){
        return sqrt(x*x + y*y);
    }

    boolean dfs(int num, int x, int y, boolean f1, boolean f2){
        if (d(x, y) >= d){
            return true;
        }
        boolean f = true;
        if (num == 0 && !f1){
            f &=  !dfs(1 - num, y, x, !f1, f2);
            if (!f){
                return f;
            }
        }
        if (num == 1 && !f2){
            f &= !dfs(1 - num, y, x, f1, !f2);
            if (!f){
                return f;
            }
        }
        for (int i = 0; i < n; i++){
            f &= !dfs(1 - num, x + v[i].x, y + v[i].y, f1, f2);
            if (!f){
                return f;
            }
        }
        return f;
    }
}

import java.awt.Point;
import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class ProblemD_63 {

    final boolean ONLINE_JUDGE=System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok=new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in=new BufferedReader(new InputStreamReader(System.in));
            out =new PrintWriter(System.out);
        }
        else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok=new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemD_63().run();
    }

    public void run(){
        try{
            long t1=System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2=System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    Point[] v;
    int d;
    int n;

    void solve() throws IOException{
        int x0 = readInt();
        int y0 = readInt();
        n = readInt();
        d = readInt();
        v = new Point[n];
        for (int i = 0; i < n; i++){
            v[i] = new Point(readInt(), readInt());
        }
        if (!dfs(1, x0, y0, false, false)){
            out.print("Anton");
        }else{
            out.print("Dasha");
        }
    }

    double d(int x, int y){
        return sqrt(x*x + y*y);
    }

    boolean dfs(int num, int x, int y, boolean f1, boolean f2){
        if (d(x, y) >= d){
            return true;
        }
        boolean f = false;
        if (num == 1 && !f1){
            f |=  dfs(1 - num, y, x, !f1, f2);
            if (f){
                return false;
            }
        }
        if (num == 0 && !f2){
            f |= dfs(1 - num, y, x, f1, !f2);
            if (f){
                return false;
            }
        }
        for (int i = 0; i < n; i++){
            f |= dfs(1 - num, x + v[i].x, y + v[i].y, f1, f2);
            if (f){
                return false;
            }
        }
        return true;
    }
}

import java.awt.Point;
import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class ProblemD_63 {

    final boolean ONLINE_JUDGE=System.getProperty("ONLINE_JUDGE")!=null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok=new StringTokenizer("");

    void init() throws FileNotFoundException{
        if (ONLINE_JUDGE){
            in=new BufferedReader(new InputStreamReader(System.in));
            out =new PrintWriter(System.out);
        }
        else{
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException{
        while(!tok.hasMoreTokens()){
            tok=new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException{
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException{
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException{
        return Double.parseDouble(readString());
    }

    public static void main(String[] args){
        new ProblemD_63().run();
    }

    public void run(){
        try{
            long t1=System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2=System.currentTimeMillis();
            System.err.println("Time = "+(t2-t1));
        }catch (Exception e){
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    int n;
    int d;
    Point[] v;
    int[][][] used;

    void solve() throws IOException{
        int x0 = readInt();
        int y0 = readInt();
        n = readInt();
        d = readInt();
        v = new Point[n];
        used = new int[4][800][800];
        for (int i = 0; i < n; i++){
            v[i] = new Point(readInt(), readInt());
        }
        if (dfs(1, x0, y0, false, false) == 1){
            out.print("Dasha");
        }else{
            out.print("Anton");
        }
    }

    double d(int x, int y){
        return sqrt(x*x + y*y);
    }

    int ind(boolean f1, boolean f2){
        return f1? f2? 3: 2: f2? 1: 0;
    }

    int dfs(int num, int x, int y, boolean f1, boolean f2){
        int ind = ind(f1, f2);
        if (used[ind][x+200][y+200] != 0){
            return used[ind][x+200][y+200];
        }
        if (d(x, y) >= d){
            return used[ind][x+200][y+200] = -1;
        }
        if (num == 1 && !f1){
            if (dfs(1 - num, y, x, !f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        if (num == 0 && !f2){
            if (dfs(1 - num, y, x, f1, !f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        for (int i = 0; i < n; i++){
            if (dfs(1 - num, x + v[i].x, y + v[i].y, f1, f2) == 1){
                return used[ind][x+200][y+200] = -1;
            }
        }
        return used[ind][x+200][y+200] = 1;
    }
}

import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class BetaRound63_Div2_D implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    public static void main(String[] args) {
        new Thread(null, new BetaRound63_Div2_D(), "", 256 * (1L << 20)).start();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            if (System.getProperty("ONLINE_JUDGE") != null) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            } else {
                in = new BufferedReader(new FileReader("input.txt"));
                out = new PrintWriter("output.txt");
            }
            Locale.setDefault(Locale.US);
            solve();
            in.close();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Throwable t) {
            t.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    // solution

    final int shift = 401, size = 2*shift + 1;

    int sx, sy, n, d;
    int[] vx, vy;

    boolean[][][][] dp;
    boolean[][][][] vis;

    boolean ok(int x, int y) {
        return (x - sx) * (x - sx) + (y - sy) * (y - sy) > d * d;
    }

    boolean get(int x, int y, int used1, int used2) {
        if (ok(x, y)) {
            return true;
        }
        if (vis[used1][used2][x][y]) {
            return dp[used1][used2][x][y];
        }

        boolean result = false;
        if (used1 == 0) {
            result |= !get(y, x, used2, 1);
        }
        for (int i = 0; i < n; i++) {
            result |= !get(x + vx[i], y + vy[i], used2, used1);
        }

        vis[used1][used2][x][y] = true;
        return dp[used1][used2][x][y] = result;
    }

    void solve() throws IOException {
        sx = readInt() + shift;
        sy = readInt() + shift;
        n = readInt();
        d = readInt();
        vx = new int[n];
        vy = new int[n];
        for (int i = 0; i < n; i++) {
            vx[i] = readInt() + shift;
            vy[i] = readInt() + shift;
        }
        // used 1, used 2, x, y
        dp = new boolean[2][2][size][size];
        vis = new boolean[2][2][size][size];
        boolean ans = get(sx, sy, 0, 0);
        out.println(ans ? "Anton" : "Dasha");
    }

}

import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class BetaRound63_Div2_D implements Runnable {

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	public static void main(String[] args) {
		new Thread(null, new BetaRound63_Div2_D(), "", 256 * (1L << 20)).start();
	}

	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			if (System.getProperty("ONLINE_JUDGE") != null) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			}
			Locale.setDefault(Locale.US);
			solve();
			in.close();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Throwable t) {
			t.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	// solution

	final int shift = 401, size = 2*shift + 1;

	int sx, sy, n, d;
	int[] vx, vy;

	boolean[][][][] dp;
	boolean[][][][] vis;

	boolean ok(int x, int y) {
		return (x - shift) * (x - shift) + (y - shift) * (y - shift) > d * d;
	}

	boolean get(int x, int y, int used1, int used2) {
		if (ok(x, y)) {
			return false;
		}
		if (vis[used1][used2][x][y]) {
			return dp[used1][used2][x][y];
		}

		boolean result = false;
		if (used1 == 0) {
			result |= !get(y, x, used2, 1);
		}
		for (int i = 0; i < n; i++) {
			result |= !get(x + vx[i], y + vy[i], used2, used1);
		}

		vis[used1][used2][x][y] = true;
		return dp[used1][used2][x][y] = result;
	}

	void solve() throws IOException {
		sx = readInt() + shift;
		sy = readInt() + shift;
		n = readInt();
		d = readInt();
		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = readInt();
			vy[i] = readInt();
		}
		// used 1, used 2, x, y
		dp = new boolean[2][2][size][size];
		vis = new boolean[2][2][size][size];
		boolean ans = get(sx, sy, 0, 0);
		out.println(ans ? "Anton" : "Dasha");
	}

}

import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class BetaRound63_Div2_D implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    public static void main(String[] args) {
        new Thread(null, new BetaRound63_Div2_D(), "", 256 * (1L << 20)).start();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            if (System.getProperty("ONLINE_JUDGE") != null) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            } else {
                in = new BufferedReader(new FileReader("input.txt"));
                out = new PrintWriter("output.txt");
            }
            Locale.setDefault(Locale.US);
            solve();
            in.close();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Throwable t) {
            t.printStackTrace(System.err);
            System.exit(-1);
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    // solution

    final int shift = 401, size = 2*shift + 1;

    int sx, sy, n, d;
    int[] vx, vy;

    boolean[][][][] dp;
    boolean[][][][] vis;

    boolean ok(int x, int y) {
        return (x - sx) * (x - sx) + (y - sy) * (y - sy) > d * d;
    }

    boolean get(int x, int y, int used1, int used2) {
        if (ok(x, y)) {
            return false;
        }
        if (vis[used1][used2][x][y]) {
            return dp[used1][used2][x][y];
        }

        boolean result = false;
        if (used1 == 0) {
            result |= !get(y, x, used2, 1);
        }
        for (int i = 0; i < n; i++) {
            result |= !get(x + vx[i], y + vy[i], used2, used1);
        }

        vis[used1][used2][x][y] = true;
        return dp[used1][used2][x][y] = result;
    }

    void solve() throws IOException {
        sx = readInt() + shift;
        sy = readInt() + shift;
        n = readInt();
        d = readInt();
        vx = new int[n];
        vy = new int[n];
        for (int i = 0; i < n; i++) {
            vx[i] = readInt();
            vy[i] = readInt();
        }
        // used 1, used 2, x, y
        dp = new boolean[2][2][size][size];
        vis = new boolean[2][2][size][size];
        boolean ans = get(sx, sy, 0, 0);
        out.println(ans ? "Anton" : "Dasha");
    }

}

import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class BetaRound63_Div2_D implements Runnable {

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	public static void main(String[] args) {
		new Thread(null, new BetaRound63_Div2_D(), "", 256 * (1L << 20)).start();
	}

	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			if (System.getProperty("ONLINE_JUDGE") != null) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter("output.txt");
			}
			Locale.setDefault(Locale.US);
			solve();
			in.close();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Throwable t) {
			t.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	// solution

	final int shift = 401, size = 2*shift + 1;

	int sx, sy, n, d;
	int[] vx, vy;

	boolean[][][][] dp;
	boolean[][][][] vis;

	boolean ok(int x, int y) {
		return (x - sx) * (x - sx) + (y - sy) * (y - sy) > d * d;
	}

	boolean get(int x, int y, int used1, int used2) {
		if (ok(x, y)) {
			return false;
		}
		if (vis[used1][used2][x][y]) {
			return dp[used1][used2][x][y];
		}

		boolean result = false;
		if (used1 == 0) {
			result |= !get(y, x, used2, 1);
		}
		for (int i = 0; i < n; i++) {
			result |= !get(x + vx[i], y + vy[i], used2, used1);
		}

		vis[used1][used2][x][y] = true;
		return dp[used1][used2][x][y] = result;
	}

	void solve() throws IOException {
		sx = readInt() + shift;
		sy = readInt() + shift;
		n = readInt();
		d = readInt();
		vx = new int[n];
		vy = new int[n];
		for (int i = 0; i < n; i++) {
			vx[i] = readInt() + shift;
			vy[i] = readInt() + shift;
		}
		// used 1, used 2, x, y
		dp = new boolean[2][2][size][size];
		vis = new boolean[2][2][size][size];
		boolean ans = get(sx, sy, 0, 0);
		out.println(ans ? "Anton" : "Dasha");
	}

}