Andrew was very excited to participate in Olympiad of Metropolises. Days flew by quickly, and Andrew is already at the airport, ready to go home. He has n rubles left, and would like to exchange them to euro and dollar bills. Andrew can mix dollar bills and euro bills in whatever way he wants. The price of one dollar is d rubles, and one euro costs e rubles.

Recall that there exist the following dollar bills: 1, 2, 5, 10, 20, 50, 100, and the following euro bills — 5, 10, 20, 50, 100, 200 (note that, in this problem we do not consider the 500 euro bill, it is hard to find such bills in the currency exchange points). Andrew can buy any combination of bills, and his goal is to minimize the total number of rubles he will have after the exchange.

Help him — write a program that given integers n, e and d, finds the minimum number of rubles Andrew can get after buying dollar and euro bills.

Input

The first line of the input contains one integer n (1 ≤ n ≤ 10^8) — the initial sum in rubles Andrew has. 

The second line of the input contains one integer d (30 ≤ d ≤ 100) — the price of one dollar in rubles. 

The third line of the input contains integer e (30 ≤ e ≤ 100) — the price of one euro in rubles.

Output

Output one integer — the minimum number of rubles Andrew can have after buying dollar and euro bills optimally.

Examples

Input


100
60
70


Output


40


Input


410
55
70


Output


5


Input


600
60
70


Output


0

Note

In the first example, we can buy just 1 dollar because there is no 1 euro bill.

In the second example, optimal exchange is to buy 5 euro and 1 dollar.

In the third example, optimal exchange is to buy 10 dollars in one bill.
import java.util.*;
import java.io.*;



public class Main {
    /*
     * HashMap<> map=new HashMap<>(); TreeMap<> map=new TreeMap<>();
     * map.put(p,map.getOrDefault(p,0)+1); for(Map.Entry<> mx:map.entrySet()){ int
     * v=mx.getValue(),k=mx.getKey(); }for (int i = 1; i <= 1000; i++) fac[i] =
     * fac[i - 1] * i % mod; ArrayList<Pair<Character,Integer>> l=new ArrayList<>();
     * ArrayList<> l=new ArrayList<>(); HashSet<> has=new HashSet<>();
     * PriorityQueue<Integer> pq=new PriorityQueue<>(new Comparator<Integer>(){
     * public int compare(Integer a,Integer b){ return Integer.compare(b,a); } });
     * Arrays.sort(ar,new Comparator<int[]>() { public int compare(int[] a, int[] b)
     * { return Double.compare(a[0], b[0]); } });
     */
    PrintWriter out;
    FastReader sc;
    long mod = (long) (1e9 + 7);
    long maxlong = Long.MAX_VALUE;
    long minlong = Long.MIN_VALUE;

    /******************************************************************************************
     *****************************************************************************************/
    public void sol() {
          int n=ni(),d=ni(),e=ni();
        
          int ans = n;
    for (int i = 0; i * 5 * e <= n; ++i) {
        ans = min(ans, (n - i * 5 * e) % d);
    }
    pl(ans);
    }

    public static void main(String[] args) {
        Main g = new Main();
        g.out = new PrintWriter(System.out);
        g.sc = new FastReader();
        int t = 1;
        // t=g.ni();
        while (t-- > 0)
            g.sol();
        g.out.flush();
    }

    /****************************************************************************************
     *****************************************************************************************/
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

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

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

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

    public char[] rl() {
        return sc.nextLine().toCharArray();
    }

    public String rl1() {
        return sc.nextLine();
    }

    public void pl(Object s) {
        out.println(s);
    }

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

    public void pr(Object s) {
        out.print(s);
    }

    public String next() {
        return sc.next();
    }

    public long abs(long x) {
        return Math.abs(x);
    }

    public int abs(int x) {
        return Math.abs(x);
    }

    public double abs(double x) {
        return Math.abs(x);
    }

    public long min(long x, long y) {
        return  Math.min(x, y);
    }

    public int min(int x, int y) {
        return  Math.min(x, y);
    }

    public double min(double x, double y) {
        return Math.min(x, y);
    }

    public long gcd(long a, long b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    public long lcm(long a, long b) {
        return (a / gcd(a, b)) * b;
    }

    void sort1(int[] a) {
        ArrayList<Integer> l = new ArrayList<>();
        for (int i : a) {
            l.add(i);
        }
        Collections.sort(l, Collections.reverseOrder());
        for (int i = 0; i < a.length; i++) {
            a[i] = l.get(i);
        }
    }

    void sort(int[] a) {
        ArrayList<Integer> l = new ArrayList<>();
        for (int i : a) {
            l.add(i);
        }
        Collections.sort(l);
        for (int i = 0; i < a.length; i++) {
            a[i] = l.get(i);
        }
    }

    void sort(long[] a) {
        ArrayList<Long> l = new ArrayList<>();
        for (long i : a) {
            l.add(i);
        }
        Collections.sort(l);
        for (int i = 0; i < a.length; i++) {
            a[i] = l.get(i);
        }
    }

    void sort1(long[] a) {
        ArrayList<Long> l = new ArrayList<>();
        for (long i : a) {
            l.add(i);
        }
        Collections.sort(l, Collections.reverseOrder());
        for (int i = 0; i < a.length; i++) {
            a[i] = l.get(i);
        }
    }

    void sort(double[] a) {
        ArrayList<Double> l = new ArrayList<>();
        for (double i : a) {
            l.add(i);
        }
        Collections.sort(l);
        for (int i = 0; i < a.length; i++) {
            a[i] = l.get(i);
        }
    }

    long pow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        long p = pow(a, b / 2);
        if (b % 2 == 0)
            return (p * p);
        else
            return ((p * p) * a);
    }

    int swap(int a, int b) {
        return a;
    }

    long swap(long a, long b) {
        return a;
    }

    double swap(double a, double b) {
        return a;
    }

    boolean isPowerOfTwo(int x) {
        return x != 0 && ((x & (x - 1)) == 0);
    }

    boolean isPowerOfTwo(long x) {
        return x != 0 && ((x & (x - 1)) == 0);
    }

    public long max(long x, long y) {
        return  Math.max(x, y);
    }

    public int max(int x, int y) {
        return  Math.max(x, y);
    }

    public double max(double x, double y) {
        return Math.max(x, y);
    }

    long sqrt(long x) {
        return (long) Math.sqrt(x);
    }

    int sqrt(int x) {
        return (int) Math.sqrt(x);
    }

    void input(int[] ar, int n) {
        for (int i = 0; i < n; i++)
            ar[i] = ni();
    }

    void input(long[] ar, int n) {
        for (int i = 0; i < n; i++)
            ar[i] = nl();
    }

    void fill(int[] ar, int k) {
        Arrays.fill(ar, k);
    }

    void yes() {
        pl("YES");
    }

    void no() {
        pl("NO");
    }

    long[] sieve(int n) {
        long[] k = new long[n + 1];
        boolean[] pr = new boolean[n + 1];
        for (int i = 1; i <= n; i++) {
            k[i] = i;
            pr[i] = true;
        }
        for (int i = 2; i <= n; i++) {
            if (pr[i]) {
                for (int j = i + i; j <= n; j += i) {
                    pr[j] = false;
                    if (k[j] == j) {
                        k[j] = i;
                    }
                }
            }
        }
        return k;
    }

    int strSmall(int[] arr, int target) {
        int start = 0, end = arr.length - 1;
        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;
            if (arr[mid] >= target) {
                end = mid - 1;
            } else {
                ans = mid;
                start = mid + 1;
            }
        }
        return ans;
    }

    int strSmall(ArrayList<Integer> arr, int target) {
        int start = 0, end = arr.size() - 1;
        int ans = -1;
        while (start <= end) {
            int mid = (start + end) / 2;
            if (arr.get(mid) > target) {
                start = mid + 1;
                ans = start;
            } else {
                end = mid - 1;
            }
        }
        return ans;
    }

    long mMultiplication(long a, long b) {
        long res = 0;
        a %= mod;

        while (b > 0) {
            if ((b & 1) > 0) {
                res = (res + a) % mod;
            }
            a = (2 * a) % mod;

            b >>= 1;
        }
        return res;
    }

    long nCr(int n, int r, long p) {

        if (n < r)
            return 0;
        if (r == 0)
            return 1;
        long[] fac = new long[n + 1];
        fac[0] = 1;

        for (int i = 1; i <= n; i++)
            fac[i] = fac[i - 1] * i % p;
        return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
    }

    long power(long x, long y, long p) {
        long res = 1;
        x = x % p;

        while (y > 0) {
            if (y % 2 == 1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }

        return res;
    }

    long modInverse(long n, long p) {
        return power(n, p - 2, p);
    }

    public static class Pair implements Comparable<Pair> {
        long first;
        long second;

        public Pair(long x, long y) {
            this.first = x;
            this.second = y;
        }public int hashCode(){
              return this.hashCode();
        }

        public int compareTo(Pair other) {
            if (this.first == other.first) {
                return Long.compare(this.second, other.second);
            }
            return Long.compare(this.first, other.first);
        }

        public boolean equals(Object o) {
  
        // If the object is compared with itself then return true  
        if (o == this) {
            return true;
        }
        /* Check if o is an instance of Complex or not
          "null instanceof [type]" also returns false */
        if (!(o instanceof Pair)) {
            return false;
        }
          
        // typecast o to Complex so that we can compare data members 
        Pair c = (Pair) o;
          
        // Compare the data members and return accordingly 
        return Long.compare(first, c.first) == 0
                && Long.compare(second, c.second) == 0;
    }

}
}