Monocarp has decided to buy a new TV set and hang it on the wall in his flat. The wall has enough free space so Monocarp can buy a TV set with screen width not greater than a and screen height not greater than b. Monocarp is also used to TV sets with a certain aspect ratio: formally, if the width of the screen is w, and the height of the screen is h, then the following condition should be met: w/h = x/y.

There are many different TV sets in the shop. Monocarp is sure that for any pair of positive integers w and h there is a TV set with screen width w and height h in the shop.

Monocarp isn't ready to choose the exact TV set he is going to buy. Firstly he wants to determine the optimal screen resolution. He has decided to try all possible variants of screen size. But he must count the number of pairs of positive integers w and h, beforehand, such that (w ≤ a), (h ≤ b) and (w/h = x/y).

In other words, Monocarp wants to determine the number of TV sets having aspect ratio x/y, screen width not exceeding a, and screen height not exceeding b. Two TV sets are considered different if they have different screen width or different screen height.

Input

The first line contains four integers a, b, x, y (1 ≤ a, b, x, y ≤ 10^{18}) — the constraints on the screen width and height, and on the aspect ratio.

Output

Print one integer — the number of different variants to choose TV screen width and screen height so that they meet the aforementioned constraints.

Examples

Input

17 15 5 3


Output

3


Input

14 16 7 22


Output

0


Input

4 2 6 4


Output

1


Input

1000000000000000000 1000000000000000000 999999866000004473 999999822000007597


Output

1000000063

Note

In the first example, there are 3 possible variants: (5, 3), (10, 6), (15, 9).

In the second example, there is no TV set meeting the constraints.

In the third example, there is only one variant: (3, 2).
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

    static boolean fileIO = false;

    public static void main(String[] args) throws Exception {
        InputStream is = null;
        OutputStream os = null;
        if (fileIO) {
            is = new FileInputStream("input.txt");
            os = new FileOutputStream("output.txt");
        } else {
            is = System.in;
            os = System.out;
        }
        InputReader in = InputReader.getInstance(is);
        PrintWriter out = new PrintWriter(os);
        new Task_BigInteger().solve(in, out);
        out.close();
    }
}

class SegmentTree {

    private int t[];
    private int size; // size of source array A
    private int NIL = 0x7FFFFFFF; // CONST to indicate unused value

    public SegmentTree(int a[]) {
        int sz = 1;
        while (sz < a.length) sz <<= 1;
        size = a.length;
        t = new int[2 * sz];
        t[1] = build(a, 1, 0, size - 1);
    }

    private int build(int a[], int id, int L, int R) {

        //
        if (L == R) {
            t[id] = a[L];
        } else {
            int mid = (L + R) >> 1;
            t[id] = build(a, id << 1, L, mid) + build(a, (id << 1) + 1, mid + 1, R);
        }
        return t[id];
    }

    public void update(int i, int diff) {
        update(1, 0, size - 1, i, diff);
    }

    private void update(int id, int L, int R, int i, int diff) {
        if (L == R) { // leaf node
            t[id] += diff;
        } else {
            int mid = (L + R) >> 1;
            if (i <= mid) {
                update(id << 1, L, mid, i, diff);
            } else {
                update((id << 1) + 1, mid + 1, R, i, diff);
            }
            t[id] = t[id << 1] + t[(id << 1) + 1];
        }
    }

    public int query(int i, int j) {
        return query(1, 0, size - 1, i, j);
    }

    private int query(int id, int L, int R, int i, int j) {
        if (i <= L && j >= R) {
            return t[id];
        } else {
            int mid = (L + R) >> 1;
            int ql = (mid >= i) ? query(id << 1, L, mid, i, j) : NIL;
            int qr = (mid + 1 <= j) ? query((id << 1) + 1, mid + 1, R, i, j) : NIL;
            return ql == NIL ? qr : qr == NIL ? ql : qr + ql;
        }
    }
}



class DisjointUnionSets {

    int rank[], parent[];
    int V;

    public DisjointUnionSets(int V) {
        this.V = V;
        rank = new int[V];
        parent = new int[V];
        //
        for (int i = 0; i < V; i++) parent[i] = i;
    }

    int find(int x) {
        //
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }

    void union(int x, int y) {
        int xRoot = find(x);
        int yRoot = find(y);
        if (xRoot == yRoot) return;
        if (rank[xRoot] < rank[yRoot]) {
            parent[xRoot] = yRoot;
        } else if (rank[xRoot] > rank[yRoot]) {
            parent[yRoot] = xRoot;
        } else {
            parent[yRoot] = xRoot;
            rank[xRoot] += 1;
        }
    }
}



class Dijkstra {

    class Pair implements Comparable< Pair > {
        long w;
        int v;
        public Pair(long w, int v) {
            this.v = v;
            this.w = w;
        }

        @Override
        public int compareTo(Pair rhs) {
            if (this.w > rhs.w) {
                return 1;
            } else if (this.w == rhs.w) {
                return 0;
            } else {
                return -1;
            }
        }

        @Override
        public String toString() {
            return "[" + w + " " + v + "]";
        }
    }

    private ArrayList< Pair > adj[];
    private long dist[];
    private int par[];

    public void solve(InputReader in, PrintWriter out) {
        int n = in.nextInt();
        int m = in.nextInt();
        int s = 0; // start vertex
        int t = n - 1; // target vertex
        //
        adj = new ArrayList[n];
        for (int i = 0; i < n; ++i) {
            adj[i] = new ArrayList<>();
        }
        while (m > 0) {
            int u = in.nextInt() - 1, v = in.nextInt() - 1, w = in.nextInt();
            adj[u].add(new Pair(w, v));
            adj[v].add(new Pair(w, u));
            --m;
        }
        dist = new long[n];
        par = new int[n];
        for (int i = 0; i < n; ++i) {
            dist[i] = Long.MAX_VALUE;
            par[i] = -1;
        }
        PriorityQueue< Pair > pq = new PriorityQueue<>();
        dist[s] = 0;
        pq.add(new Pair(0, s));
        // in priority queue Pair (dist, v) means
        // shortest distance = dist from source to vertex = v calculated so far.
        while (!pq.isEmpty()) {
            Pair cur = pq.poll();
            if (dist[cur.v] < cur.w) {
                continue;
            }

            for (Pair to : adj[cur.v]) {
                if (dist[to.v] > dist[cur.v] + to.w) {
                    dist[to.v] = dist[cur.v] + to.w;
                    pq.add(new Pair(dist[to.v], to.v));
                    par[to.v] = cur.v;
                }
            }
        }
        if (dist[t] < Long.MAX_VALUE) {
            Stack< Integer > answer = new Stack<>();
            for (int cur = t; cur != -1; cur = par[cur]) {
                answer.push(cur);
            }
            while (!answer.isEmpty()) {
                out.print((answer.pop() + 1) + " ");
            }
            out.println();
        } else {
            out.println(-1);
        }
    }
}


class Task_BigInteger {

    public void solve(InputReader in, PrintWriter out) {
        BigInteger a = new BigInteger(in.nextString());
        BigInteger b = new BigInteger(in.nextString());
        BigInteger x = new BigInteger(in.nextString());
        BigInteger y = new BigInteger(in.nextString());
        BigInteger gcd = x.gcd(y);
        if (!gcd.equals(1)) {
            x = x.divide(gcd);
            y = y.divide(gcd);
        }
        BigInteger k1 = a.divide(x), r1 = a.remainder(x);
        BigInteger k2 = b.divide(y), r2 = b.remainder(y);

        BigInteger answer;
        if (k1.compareTo(k2) >= 0) {
            answer = k2;
        } else {
            answer = k1;
        }
        out.print(answer.toString());
    }
}



class InputReader {
    private static InputReader instance;

    private InputStream stream;
    private byte[] buf;
    private int curChar, snumChars;

    private SpaceCharFilter filter;


    private InputReader(InputStream stream) {
        this.stream = stream;
        this.buf = new byte[8192];
        this.curChar = this.snumChars = 0;
        this.filter = new SpaceCharFilter() {
            @Override
            public boolean isSpaceChar(int ch) {
                return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == -1;
            }
        };
    }

    public static InputReader getInstance(InputStream stream) {
        if (instance == null) {
            instance = new InputReader(stream);
        }
        return instance;
    }

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

    public int nextInt() {
        int c = nextChar();
        while (filter.isSpaceChar(c)) {
            c = nextChar();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = nextChar();
        }
        int res = 0;
        while (!filter.isSpaceChar(c)) {
            if (c < '0' || c > '9') {
                throw new InputMismatchException();
            }
            res *= 10;
            res += c - '0';
            c = nextChar();
        }
        return res * sgn;
    }
    public String nextString() {
        int c = nextChar();
        while (filter.isSpaceChar(c)) {
            c = nextChar();
        }
        StringBuilder res = new StringBuilder();
        while (!filter.isSpaceChar(c)) {
            res.appendCodePoint(c);
            c = nextChar();
        }
        return res.toString();
    }
    public double nextDouble() {
        return Double.parseDouble(nextString());
    }
    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

