Problem: A MIPT student named Misha has a birthday today, and he decided to celebrate it in his country house in suburban Moscow. n friends came by, and after a typical party they decided to play blind man's buff.

The birthday boy gets blindfolded and the other players scatter around the house. The game is played in several rounds. In each round, Misha catches exactly one of his friends and has to guess who it is. The probability of catching the i-th friend does not change between rounds and is equal to pi percent (as we know, it is directly proportional to the amount of alcohol consumed by the i-th friend) and p1 + p2 + ... + pn = 100 holds. Misha has no information about who he caught. After Misha makes an attempt to guess the caught person, the round ends. Even then, Misha isn't told whether he guessed correctly, and a new round begins.

The game ends when Misha guesses every friend at least once, that is, there exists such set of rounds k1, k2, ..., kn, that during round number ki Misha caught the i-th friend and guessed him. Misha wants to minimize the expectation of the number of rounds of the game. Despite the fact that at any point in the game Misha has no information about who he has already guessed, his friends are honest, and if they see that the condition for the end of the game is fulfilled, the game ends immediately. Find the expectation of the number of rounds in the game if Misha plays optimally.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of Misha's friends.

The second line contains n integers pi (<image>), giving the probability to catch the i-th friend in one particular round in percent.

Output

Print a single real value — the expectation of the number of rounds provided that Misha plays optimally. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

2
50 50


Output

5.0000000000


Input

4
50 20 20 10


Output

39.2846263444

Note

The optimal strategy in the first sample is to guess friends alternately.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.math.BigDecimal;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            DBirthday solver = new DBirthday();
            solver.solve(1, in, out);
            out.close();
        }
    }

    static class DBirthday {
        Debug debug = new Debug(true);

        public double success(double failP, int round) {
            return Math.log(1 - Math.pow(failP, round));
        }

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.readInt();
            double[] p = new double[n];
            double[] q = new double[n];
            for (int i = 0; i < n; i++) {
                p[i] = in.readInt() / 100d;
                q[i] = 1 - p[i];
            }

            double[] prev = new double[n];
            double[] next = new double[n];
            int[] time = new int[n];
            KahamSummation now = new KahamSummation();
            for (int i = 0; i < n; i++) {
                prev[i] = success(q[i], 1);
                now.add(prev[i]);
                next[i] = success(q[i], 2);
                time[i] = 1;
            }
            IntegerPriorityQueue pq = new IntegerPriorityQueue(n, (i, j) -> -Double.compare(next[i] - prev[i],
                    next[j] - prev[j]));
            for (int i = 0; i < n; i++) {
                pq.add(i);
            }
            KahamSummation sum = new KahamSummation();
            sum.add(n + 1);
            sum.subtract(Math.pow(Math.E, now.sum()));
            long end = System.currentTimeMillis() + 1500;
            int round = 0;
            while (round < 1000000) {
                round++;
                int peek = pq.pop();
                now.add(next[peek]);
                now.subtract(prev[peek]);
                prev[peek] = next[peek];
                time[peek]++;
                next[peek] = success(q[peek], time[peek] + 1);
                pq.add(peek);
                sum.add(1);
                double sub = Math.pow(Math.E, now.sum());
                sum.subtract(sub);
                // debug.debug("sub", sub);
            }

            out.println(sum.sum());
            debug.debug("round", round);
        }

    }

    static class FastInput {
        private final InputStream is;
        private byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

    }

    static class KahamSummation {
        private double error;
        private double sum;

        public double sum() {
            return sum;
        }

        public void add(double x) {
            x = x - error;
            double t = sum + x;
            error = (t - sum) - x;
            sum = t;
        }

        public void subtract(double x) {
            add(-x);
        }

        public String toString() {
            return new BigDecimal(sum).toString();
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private static final int THRESHOLD = 1 << 13;
        private final Writer os;
        private StringBuilder cache = new StringBuilder(THRESHOLD * 2);

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        private void afterWrite() {
            if (cache.length() < THRESHOLD) {
                return;
            }
            flush();
        }

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(char c) {
            cache.append(c);
            afterWrite();
            return this;
        }

        public FastOutput append(double c) {
            cache.append(new BigDecimal(c).toPlainString());
            afterWrite();
            return this;
        }

        public FastOutput append(String c) {
            cache.append(c);
            afterWrite();
            return this;
        }

        public FastOutput println(double c) {
            return append(c).println();
        }

        public FastOutput println() {
            return append(System.lineSeparator());
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }

    static class SequenceUtils {
        public static void swap(int[] data, int i, int j) {
            int tmp = data[i];
            data[i] = data[j];
            data[j] = tmp;
        }

    }

    static class Debug {
        private boolean offline;
        private PrintStream out = System.err;

        public Debug(boolean enable) {
            offline = enable && System.getSecurityManager() == null;
        }

        public Debug debug(String name, int x) {
            if (offline) {
                debug(name, "" + x);
            }
            return this;
        }

        public Debug debug(String name, String x) {
            if (offline) {
                out.printf("%s=%s", name, x);
                out.println();
            }
            return this;
        }

    }

    static class IntegerPriorityQueue implements Cloneable {
        private int[] data;
        private IntegerComparator comparator;
        private int size;

        public IntegerPriorityQueue(int n, IntegerComparator comparator) {
            this.data = new int[n + 1];
            this.comparator = comparator;
        }

        private int left(int i) {
            return i << 1;
        }

        private int right(int i) {
            return (i << 1) | 1;
        }

        private int parent(int i) {
            return i >> 1;
        }

        public void add(int x) {
            data[++size] = x;
            shiftUp(size);
        }

        private void shiftUp(int index) {
            while (index != 1) {
                int pid = parent(index);
                if (comparator.compare(data[pid], data[index]) <= 0) {
                    break;
                }
                SequenceUtils.swap(data, index, pid);
                index = pid;
            }
        }

        private void shiftDown(int index) {
            while (true) {
                int lid = left(index);
                int rid = right(index);
                if (lid > size) {
                    break;
                }
                int challenger = lid;
                if (rid <= size && comparator.compare(data[rid], data[lid]) < 0) {
                    challenger = rid;
                }
                if (comparator.compare(data[challenger], data[index]) >= 0) {
                    break;
                }
                SequenceUtils.swap(data, index, challenger);
                index = challenger;
            }
        }

        public int pop() {
            int ans = data[1];
            SequenceUtils.swap(data, 1, size);
            size--;
            shiftDown(1);
            return ans;
        }

        public boolean isEmpty() {
            return size == 0;
        }

        public IntegerPriorityQueue clone() {
            try {
                IntegerPriorityQueue c = (IntegerPriorityQueue) super.clone();
                c.data = data.clone();
                return c;
            } catch (CloneNotSupportedException e) {
                throw new RuntimeException(e);
            }
        }

        public String toString() {
            StringBuilder builder = new StringBuilder();
            IntegerPriorityQueue queue = clone();
            while (!queue.isEmpty()) {
                builder.append(queue.pop()).append(',');
            }
            if (builder.length() > 0) {
                builder.setLength(builder.length() - 1);
            }
            return builder.toString();
        }

    }

    static interface IntegerComparator {
        public int compare(int a, int b);

    }
}