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 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.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();}

	}
}

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");
    }
}

// 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.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.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.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.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.*;
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");
	}

}

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 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;
	}
}

// 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");
	}

}