There are N positive integers arranged in a circle.

Now, the i-th number is A_i. Takahashi wants the i-th number to be B_i. For this objective, he will repeatedly perform the following operation:

* Choose an integer i such that 1 \leq i \leq N.
* Let a, b, c be the (i-1)-th, i-th, and (i+1)-th numbers, respectively. Replace the i-th number with a+b+c.



Here the 0-th number is the N-th number, and the (N+1)-th number is the 1-st number.

Determine if Takahashi can achieve his objective. If the answer is yes, find the minimum number of operations required.

Constraints

* 3 \leq N \leq 2 \times 10^5
* 1 \leq A_i, B_i \leq 10^9
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N
A_1 A_2 ... A_N
B_1 B_2 ... B_N


Output

Print the minimum number of operations required, or `-1` if the objective cannot be achieved.

Examples

Input

3
1 1 1
13 5 7


Output

4


Input

4
1 2 3 4
2 3 4 5


Output

-1


Input

5
5 6 5 2 1
9817 1108 6890 4343 8704


Output

25
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.Comparator;
import java.io.InputStream;

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

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            TreeSet<TaskC.Item> items = new TreeSet<>(new Comparator<TaskC.Item>() {

                public int compare(TaskC.Item o1, TaskC.Item o2) {
                    int z = o2.b - o1.b;
                    if (z == 0) z = o1.pos - o2.pos;
                    return z;
                }
            });
            TaskC.Item[] itemArr = new TaskC.Item[n];
            for (int i = 0; i < n; ++i) {
                itemArr[i] = new TaskC.Item();
                itemArr[i].pos = i;
                itemArr[i].a = in.nextInt();
            }
            for (int i = 0; i < n; ++i) {
                itemArr[i].b = in.nextInt();
                if (itemArr[i].b < itemArr[i].a) {
                    out.println(-1);
                    return;
                }
                if (itemArr[i].b > itemArr[i].a) {
                    items.add(itemArr[i]);
                }
            }
            long ops = 0;
            while (!items.isEmpty()) {
                TaskC.Item item = items.first();
                items.remove(item);
                TaskC.Item prev = itemArr[(item.pos - 1 + n) % n];
                TaskC.Item next = itemArr[(item.pos + 1) % n];
                long step = prev.b + next.b;
                long maxSteps = (item.b - Math.max(item.a, Math.max(prev.b, next.b)) + step - 1) / step;
                if (maxSteps == 0) {
                    out.println(-1);
                    return;
                }
                item.b -= step * maxSteps;
                ops += maxSteps;
                if (item.b < item.a) {
                    out.println(-1);
                    return;
                }
                if (item.b > item.a) {
                    items.add(item);
                }
            }
            out.println(ops);
        }

        static class Item {
            int pos;
            int a;
            int b;

        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }
}

