Polycarp has created his own training plan to prepare for the programming contests. He will train for n days, all days are numbered from 1 to n, beginning from the first.

On the i-th day Polycarp will necessarily solve a_i problems. One evening Polycarp plans to celebrate the equator. He will celebrate it on the first evening of such a day that from the beginning of the training and to this day inclusive he will solve half or more of all the problems.

Determine the index of day when Polycarp will celebrate the equator.

Input

The first line contains a single integer n (1 ≤ n ≤ 200 000) — the number of days to prepare for the programming contests.

The second line contains a sequence a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10 000), where a_i equals to the number of problems, which Polycarp will solve on the i-th day.

Output

Print the index of the day when Polycarp will celebrate the equator.

Examples

Input

4
1 3 2 1


Output

2


Input

6
2 2 2 2 2 2


Output

3

Note

In the first example Polycarp will celebrate the equator on the evening of the second day, because up to this day (inclusive) he will solve 4 out of 7 scheduled problems on four days of the training.

In the second example Polycarp will celebrate the equator on the evening of the third day, because up to this day (inclusive) he will solve 6 out of 12 scheduled problems on six days of the training.
import java.io.IOException;
import java.math.BigInteger;
import java.util.*;
import java.io.*;

public class ll {
    public static void main(String[] args) throws Exception {
        gg g = new gg();
    }

}

class gg {
    ArrayList<Integer>[] g;
    PrintWriter pw;


    gg() throws Exception {
        //    FScanner fs = new FScanner(new FileReader("multimap.in"));
        //  pw = new PrintWriter("multimap.out");
        FScanner fs = new FScanner(new InputStreamReader(System.in));
        pw = new PrintWriter(System.out);
        int n = fs.nextInt();
        int[] a = fs.iarr(n);
        long sum = 0;
        for (int i = 0; i<n; i++)
            sum+=a[i];
        int csum = 0;
        for (int i = 0; i<n; i++)
        {
            csum+=a[i];
            if (sum % 2 == 0 && csum >= sum/2 || sum % 2 != 0 && csum > sum/2) {
                pw.println(i+1);
                break;
            }
        }
        pw.close();
    }

}

class List {
    Node start;
    int size = 0;

    void freeNode(Node that, Node x) {
        if (x.before == null && x.after == null) {
            that.last = null;
        } else if (x.before == null) {
            x.after.before = null;
        } else if (x.after == null) {
            x.before.after = null;
            that.last = x.before;
        } else {
            x.before.after = x.after;
            x.after.before = x.before;
        }
    }

    void addNode(Node that, Node x) {
        x.before = that.last;
        if (that.last != null)
            that.last.after = x;
        that.last = x;
    }

    void add(Node that, String key) {
        Node a = new Node();
        a.key = key;
        a.next = start;
        addNode(that, a);
        if (start != null)
            start.prev = a;
        start = a;
        size++;
    }

    Node get(String key) {
        if (start == null)
            return null;
        Node cur = start;
        while (!cur.key.equals(key))
            cur = cur.next;
        return cur;
    }

    boolean delete(Node that, String key) {
        Node cur = start;
        while (cur != null && !cur.key.equals(key)) {
            cur = cur.next;
        }
        if (cur == null)
            return false;
        else {
            freeNode(that, cur);
            if (cur == start) {
                if (size == 1) {
                    size = 0;
                    start = null;
                } else {
                    start = start.next;
                    start.prev = null;
                    size--;
                }
                return true;
            } else {
                if (cur.next == null) {
                    cur.prev.next = null;
                    size--;
                } else {
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                    size--;
                }
                return true;
            }
        }
    }

    boolean exists(String key) {
        Node cur = start;
        while (cur != null && !cur.key.equals(key)) {
            cur = cur.next;
        }
        if (cur == null)
            return false;
        else return true;
    }
}

class Node {
    String key;
    Node last;
    Node next, prev;
    Node after, before;
    List[] h;
}

class Pair implements Comparable<Pair> {
    long a;
    int x;

    Pair(long x1, int y1) {
        a = x1;
        a = y1;
    }

    @Override
    public int compareTo(Pair o) {
        if (a == o.a)
            return Integer.compare(x, o.x);
        else return Long.compare(a, o.a);
    }
}


class FScanner {
    StringTokenizer st;
    BufferedReader reader;

    FScanner(InputStreamReader isr) throws IOException {
        reader = new BufferedReader(isr);
    }

    String nextLine() throws IOException {
        return reader.readLine();
    }

    String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String s = reader.readLine();
            if (s == null)
                return null;
            st = new StringTokenizer(s);
        }
        return st.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    char nextChar() throws IOException {
        return (char) reader.read();
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    int[] iarr(int n) throws IOException {
        int[] mas = new int[n];
        for (int i = 0; i < n; i++)
            mas[i] = nextInt();
        return mas;
    }

    double[] darr(int n) throws IOException {
        double[] mas = new double[n];
        for (int i = 0; i < n; i++)
            mas[i] = nextDouble();
        return mas;
    }

    char[][] cmas2(int n, int m) throws IOException {
        char[][] mas = new char[n][m];
        for (int i = 0; i < n; i++)
            mas[i] = nextLine().toCharArray();
        return mas;
    }

    long[] larr(int n) throws IOException {
        long[] mas = new long[n];
        for (int i = 0; i < n; i++)
            mas[i] = nextLong();
        return mas;
    }
}

class PairP implements Comparable<PairP> {
    double l, r;

    PairP(double l1, double r1) {
        l = l1;
        r = r1;
    }

    @Override
    public int compareTo(PairP o) {
        if (l == o.l)
            return Double.compare(r, o.r);
        else return Double.compare(l, o.l);
    }
}