Ani and Borna are playing a short game on a two-variable polynomial. It's a special kind of a polynomial: the monomials are fixed, but all of its coefficients are fill-in-the-blanks dashes, e.g. $$$ \\_ xy + \\_ x^4 y^7 + \\_ x^8 y^3 + … $$$

Borna will fill in the blanks with positive integers. He wants the polynomial to be bounded from below, i.e. his goal is to make sure there exists a real number M such that the value of the polynomial at any point is greater than M. 

Ani is mischievous, and wants the polynomial to be unbounded. Along with stealing Borna's heart, she can also steal parts of polynomials. Ani is only a petty kind of thief, though: she can only steal at most one monomial from the polynomial before Borna fills in the blanks. 

If Ani and Borna play their only moves optimally, who wins?

Input

The first line contains a positive integer N (2 ≤ N ≤ 200  000), denoting the number of the terms in the starting special polynomial.

Each of the following N lines contains a description of a monomial: the k-th line contains two **space**-separated integers a_k and b_k (0 ≤ a_k, b_k ≤ 10^9) which mean the starting polynomial has the term \\_ x^{a_k} y^{b_k}. It is guaranteed that for k ≠ l, either a_k ≠ a_l or b_k ≠ b_l.

Output

If Borna can always choose the coefficients such that the resulting polynomial is bounded from below, regardless of what monomial Ani steals, output "Borna". Else, output "Ani". 

You shouldn't output the quotation marks.

Examples

Input

3
1 1
2 0
0 2


Output

Ani


Input

4
0 0
0 1
0 2
0 8


Output

Borna

Note

In the first sample, the initial polynomial is \\_xy+ \\_x^2 + \\_y^2. If Ani steals the \\_y^2 term, Borna is left with \\_xy+\\_x^2. Whatever positive integers are written on the blanks, y → -∞ and x := 1 makes the whole expression go to negative infinity.

In the second sample, the initial polynomial is \\_1 + \\_x + \\_x^2 + \\_x^8. One can check that no matter what term Ani steals, Borna can always win.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.AbstractSet;
import java.util.InputMismatchException;
import java.util.Random;
import java.util.ArrayList;
import java.util.AbstractCollection;
import java.util.Map;
import java.io.OutputStreamWriter;
import java.util.NoSuchElementException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.util.Collection;
import java.util.Set;
import java.io.IOException;
import java.util.List;
import java.util.AbstractMap;
import java.io.Writer;
import java.util.Map.Entry;
import java.util.Comparator;
import java.io.InputStream;

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

    static class FShadyLady {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.readInt();
            int[] A = new int[n], B = new int[n];
            in.readIntArrays(A, B);
            int hasOrigin = 0;
            for (int i = 0; i < n; i++) {
                if (A[i] == 0 && B[i] == 0) {
                    hasOrigin = 1;
                    break;
                }
            }
            Point[] points = new Point[n + 1 - hasOrigin];
            Arrays.setAll(points, i -> (i < n ? new Point(A[i], B[i]) : Point.ORIGIN));
            Polygon total = Polygon.convexHull(points, true);
            boolean lose = check(total);
            Set<Point> even = new EHashSet<>(), odd = new EHashSet<>();
            for (int i = 0; i < total.vertices.length; i++) {
                Point P = total.vertices[i];
                if (P.equals(Point.ORIGIN)) {
                    continue;
                }
                if (i % 2 == 0) {
                    even.add(P);
                } else {
                    odd.add(P);
                }
            }
            List<Point> notEven = new ArrayList(), notOdd = new ArrayList<>();
            for (Point P : points) {
                if (!even.contains(P)) {
                    notEven.add(P);
                }
                if (!odd.contains(P)) {
                    notOdd.add(P);
                }
            }
            Point[] notEvenArray = notEven.toArray(new Point[0]), notOddArray = notOdd.toArray(new Point[0]);
            Polygon notEvenPolygon = Polygon.convexHull(notEvenArray, true), notOddPolygon = Polygon.convexHull(notOddArray, true);
            lose |= check(notEvenPolygon);
            lose |= check(notOddPolygon);
            out.printLine(lose ? "Ani" : "Borna");
        }

        boolean check(Polygon poly) {
            for (Point p : poly.vertices) {
                long x = Math.round(p.x), y = Math.round(p.y);
                if (x % 2 == 1 || y % 2 == 1) {
                    return true;
                }
            }
            return false;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class Polygon {
        public final Point[] vertices;

        public Polygon(Point... vertices) {
            this.vertices = vertices.clone();
        }

        public static boolean over(Point a, Point b, Point c) {
            return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) < -GeometryUtils.epsilon;
        }

        private static boolean under(Point a, Point b, Point c) {
            return a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y) > GeometryUtils.epsilon;
        }

        public static Polygon convexHull(Point[] points, boolean strict) {
            if (points.length == 1) {
                return new Polygon(points);
            }
            Arrays.sort(points, Comparator.comparingDouble((Point o) -> o.x).thenComparingDouble(o -> o.y));
            Point left = points[0];
            Point right = points[points.length - 1];
            List<Point> up = new ArrayList<>();
            List<Point> down = new ArrayList<>();
            for (Point point : points) {
                if (point == left || point == right || (strict ? over(left, point, right) : !under(left, point, right))) {
                    while (up.size() >= 2 && (strict ? !over(up.get(up.size() - 2), up.get(up.size() - 1), point) : under(up.get(up.size() - 2), up.get(up.size() - 1), point))) {
                        up.remove(up.size() - 1);
                    }
                    up.add(point);
                }
                if (point == left || point == right || (strict ? under(left, point, right) : !over(left, point, right))) {
                    while (down.size() >= 2 && (strict ? !under(down.get(down.size() - 2), down.get(down.size() - 1), point) : over(down.get(down.size() - 2), down.get(down.size() - 1), point))) {
                        down.remove(down.size() - 1);
                    }
                    down.add(point);
                }
            }
            Point[] result = new Point[up.size() + down.size() - 2];
            int index = 0;
            for (Point point : up) {
                result[index++] = point;
            }
            for (int i = down.size() - 2; i > 0; i--) {
                result[index++] = down.get(i);
            }
            return new Polygon(result);
        }

    }

    static class EHashSet<E> extends AbstractSet<E> {
        private static final Object VALUE = new Object();
        private final Map<E, Object> map;

        public EHashSet() {
            this(4);
        }

        public EHashSet(int maxSize) {
            map = new EHashMap<>(maxSize);
        }

        public EHashSet(Collection<E> collection) {
            this(collection.size());
            addAll(collection);
        }

        public boolean contains(Object o) {
            return map.containsKey(o);
        }

        public boolean add(E e) {
            if (e == null) {
                return false;
            }
            return map.put(e, VALUE) == null;
        }

        public boolean remove(Object o) {
            if (o == null) {
                return false;
            }
            return map.remove(o) != null;
        }

        public void clear() {
            map.clear();
        }

        public Iterator<E> iterator() {
            return map.keySet().iterator();
        }

        public int size() {
            return map.size();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

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

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

        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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            boolean isSpaceChar(int ch);

        }

    }

    static class EHashMap<E, V> extends AbstractMap<E, V> {
        private static final int[] shifts = new int[10];
        private int size;
        private EHashMap.HashEntry<E, V>[] data;
        private int capacity;
        private Set<Entry<E, V>> entrySet;

        static {
            Random random = new Random(System.currentTimeMillis());
            for (int i = 0; i < 10; i++) {
                shifts[i] = 1 + 3 * i + random.nextInt(3);
            }
        }

        public EHashMap() {
            this(4);
        }

        private void setCapacity(int size) {
            capacity = Integer.highestOneBit(4 * size);
            //noinspection unchecked
            data = new EHashMap.HashEntry[capacity];
        }

        public EHashMap(int maxSize) {
            setCapacity(maxSize);
            entrySet = new AbstractSet<Entry<E, V>>() {

                public Iterator<Entry<E, V>> iterator() {
                    return new Iterator<Entry<E, V>>() {
                        private EHashMap.HashEntry<E, V> last = null;
                        private EHashMap.HashEntry<E, V> current = null;
                        private EHashMap.HashEntry<E, V> base = null;
                        private int lastIndex = -1;
                        private int index = -1;

                        public boolean hasNext() {
                            if (current == null) {
                                for (index++; index < capacity; index++) {
                                    if (data[index] != null) {
                                        base = current = data[index];
                                        break;
                                    }
                                }
                            }
                            return current != null;
                        }

                        public Entry<E, V> next() {
                            if (!hasNext()) {
                                throw new NoSuchElementException();
                            }
                            last = current;
                            lastIndex = index;
                            current = current.next;
                            if (base.next != last) {
                                base = base.next;
                            }
                            return last;
                        }

                        public void remove() {
                            if (last == null) {
                                throw new IllegalStateException();
                            }
                            size--;
                            if (base == last) {
                                data[lastIndex] = last.next;
                            } else {
                                base.next = last.next;
                            }
                        }
                    };
                }


                public int size() {
                    return size;
                }
            };
        }

        public EHashMap(Map<E, V> map) {
            this(map.size());
            putAll(map);
        }

        public Set<Entry<E, V>> entrySet() {
            return entrySet;
        }

        public void clear() {
            Arrays.fill(data, null);
            size = 0;
        }

        private int index(Object o) {
            return getHash(o.hashCode()) & (capacity - 1);
        }

        private int getHash(int h) {
            int result = h;
            for (int i : shifts) {
                result ^= h >>> i;
            }
            return result;
        }

        public V remove(Object o) {
            if (o == null) {
                return null;
            }
            int index = index(o);
            EHashMap.HashEntry<E, V> current = data[index];
            EHashMap.HashEntry<E, V> last = null;
            while (current != null) {
                if (current.key.equals(o)) {
                    if (last == null) {
                        data[index] = current.next;
                    } else {
                        last.next = current.next;
                    }
                    size--;
                    return current.value;
                }
                last = current;
                current = current.next;
            }
            return null;
        }

        public V put(E e, V value) {
            if (e == null) {
                return null;
            }
            int index = index(e);
            EHashMap.HashEntry<E, V> current = data[index];
            if (current != null) {
                while (true) {
                    if (current.key.equals(e)) {
                        V oldValue = current.value;
                        current.value = value;
                        return oldValue;
                    }
                    if (current.next == null) {
                        break;
                    }
                    current = current.next;
                }
            }
            if (current == null) {
                data[index] = new EHashMap.HashEntry<>(e, value);
            } else {
                current.next = new EHashMap.HashEntry<>(e, value);
            }
            size++;
            if (2 * size > capacity) {
                EHashMap.HashEntry<E, V>[] oldData = data;
                setCapacity(size);
                for (EHashMap.HashEntry<E, V> entry : oldData) {
                    while (entry != null) {
                        EHashMap.HashEntry<E, V> next = entry.next;
                        index = index(entry.key);
                        entry.next = data[index];
                        data[index] = entry;
                        entry = next;
                    }
                }
            }
            return null;
        }

        public V get(Object o) {
            if (o == null) {
                return null;
            }
            int index = index(o);
            EHashMap.HashEntry<E, V> current = data[index];
            while (current != null) {
                if (current.key.equals(o)) {
                    return current.value;
                }
                current = current.next;
            }
            return null;
        }

        public boolean containsKey(Object o) {
            if (o == null) {
                return false;
            }
            int index = index(o);
            EHashMap.HashEntry<E, V> current = data[index];
            while (current != null) {
                if (current.key.equals(o)) {
                    return true;
                }
                current = current.next;
            }
            return false;
        }

        public int size() {
            return size;
        }

        private static class HashEntry<E, V> implements Entry<E, V> {
            private final E key;
            private V value;
            private EHashMap.HashEntry<E, V> next;

            private HashEntry(E key, V value) {
                this.key = key;
                this.value = value;
            }

            public E getKey() {
                return key;
            }

            public V getValue() {
                return value;
            }

            public V setValue(V value) {
                V oldValue = this.value;
                this.value = value;
                return oldValue;
            }

        }

    }

    static class Point {
        public static final Point ORIGIN = new Point(0, 0);
        public final double x;
        public final double y;

        public String toString() {
            return "(" + x + ", " + y + ")";
        }

        public Point(double x, double y) {
            this.x = x;
            this.y = y;
        }

        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }

            Point point = (Point) o;

            return Math.abs(x - point.x) <= GeometryUtils.epsilon && Math.abs(y - point.y) <= GeometryUtils.epsilon;
        }

        public int hashCode() {
            int result;
            long temp;
            temp = x != +0.0d ? Double.doubleToLongBits(x) : 0L;
            result = (int) (temp ^ (temp >>> 32));
            temp = y != +0.0d ? Double.doubleToLongBits(y) : 0L;
            result = 31 * result + (int) (temp ^ (temp >>> 32));
            return result;
        }

    }

    static class GeometryUtils {
        public static double epsilon = 1e-8;

    }
}

