The Little Elephant has two permutations a and b of length n, consisting of numbers from 1 to n, inclusive. Let's denote the i-th (1 ≤ i ≤ n) element of the permutation a as ai, the j-th (1 ≤ j ≤ n) element of the permutation b — as bj.

The distance between permutations a and b is the minimum absolute value of the difference between the positions of the occurrences of some number in a and in b. More formally, it's such minimum |i - j|, that ai = bj.

A cyclic shift number i (1 ≤ i ≤ n) of permutation b consisting from n elements is a permutation bibi + 1... bnb1b2... bi - 1. Overall a permutation has n cyclic shifts.

The Little Elephant wonders, for all cyclic shifts of permutation b, what is the distance between the cyclic shift and permutation a?

Input

The first line contains a single integer n (1 ≤ n ≤ 105) — the size of the permutations. The second line contains permutation a as n distinct numbers from 1 to n, inclusive. The numbers are separated with single spaces. The third line contains permutation b in the same format.

Output

In n lines print n integers — the answers for cyclic shifts. Print the answers to the shifts in the order of the shifts' numeration in permutation b, that is, first for the 1-st cyclic shift, then for the 2-nd, and so on.

Examples

Input

2
1 2
2 1


Output

1
0


Input

4
2 1 3 4
3 4 2 1


Output

2
1
0
1

import java.math.*;
import java.io.*;
import java.util.*;

public class Main {
    
    public static void main(String[] args) throws IOException {
        PrintWriter out = new PrintWriter(System.out);
        FastReader in = new FastReader(new BufferedReader(new InputStreamReader(System.in)));
        Task solver = new Task();
        solver.solve(in, out);
        out.close();
    }
    
}

class Task {
    
    final int INF = Integer.MAX_VALUE / 2;
    
    public void solve(FastReader in, PrintWriter out) throws IOException {
 
        int n = in.nextInt();
        final int a[] = new int[n + 1], b[] = new int[n + 1];
        int c[] = new int[n];
        for(int i = 0; i < n; ++i) {
            a[in.nextInt() - 1] = i;
        }
        for(int i = 0; i < n; ++i) {
            b[in.nextInt() - 1] = i;
        }
        for(int i = 0; i < n; ++i) {
            c[b[i]] = i;
        }
        TreeSet<Integer> tr = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer i, Integer j) {
                if(a[i] - b[i] != a[j] - b[j]) {
                    return Integer.compare(a[i] - b[i], a[j] - b[j]);
                }
                return Integer.compare(i, j);
            }
        });
        for(int i = 0; i < n; ++i) {
            tr.add(i);
        }
        for(int i = 0; i < n; ++i) {
            int ans = INF;
            Integer low = tr.lower(n);
            Integer hig = tr.higher(n);
            if(low != null) {
                ans = Math.min(ans, -(a[low] - b[low] + i));
            }
            if(hig != null) {
                ans = Math.min(ans, a[hig] - b[hig] + i);
            }
            out.println(ans);
            int tmp = c[i];
            tr.remove(tmp);
            b[tmp] += n;
            tr.add(tmp);
            ++b[n];
        }
    }
    
}

class FastReader {
    
    BufferedReader in;
    StringBuilder sb = new StringBuilder();
    
    public FastReader(BufferedReader in) {
        this.in = in;
    }
    
    public String next() throws IOException {
        sb.setLength(0);
        while(true) {
            int c = in.read();
            if(c == -1) {
                return null;
            }
            if(" \n\r\t".indexOf(c) == -1) {
                sb.append((char)c);
                break;
            }
        }
        while(true) {
            int c = in.read();
            if(c == -1 || " \n\r\t".indexOf(c) != -1) {
                break;
            }
            sb.append((char)c);
        }
        return sb.toString();
    }
    
    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    
    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    
    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    
}
