An express train to reveries CodeForces - 814B

Sengoku still remembers the mysterious "colourful meteoroids" she discovered with Lala-chan when they were little. In particular, one of the nights impressed her deeply, giving her the illusion that all her fancies would be realized.

On that night, Sengoku constructed a permutation p₁, p₂, ..., p_n of integers from 1 to n inclusive, with each integer representing a colour, wishing for the colours to see in the coming meteor outburst. Two incredible outbursts then arrived, each with n meteorids, colours of which being integer sequences a₁, a₂, ..., a_n and b₁, b₂, ..., b_n respectively. Meteoroids' colours were also between 1 and n inclusive, and the two sequences were not identical, that is, at least one i (1 ≤ i ≤ n) exists, such that a_i ≠ b_i holds.

Well, she almost had it all — each of the sequences a and b matched exactly n - 1 elements in Sengoku's permutation. In other words, there is exactly one i (1 ≤ i ≤ n) such that a_i ≠ p_i, and exactly one j (1 ≤ j ≤ n) such that b_j ≠ p_j.

For now, Sengoku is able to recover the actual colour sequences a and b through astronomical records, but her wishes have been long forgotten. You are to reconstruct any possible permutation Sengoku could have had on that night.

Input

The first line of input contains a positive integer n (2 ≤ n ≤ 1 000) — the length of Sengoku's permutation, being the length of both meteor outbursts at the same time.

The second line contains n space-separated integers a₁, a₂, ..., a_n (1 ≤ a_i ≤ n) — the sequence of colours in the first meteor outburst.

The third line contains n space-separated integers b₁, b₂, ..., b_n (1 ≤ b_i ≤ n) — the sequence of colours in the second meteor outburst. At least one i (1 ≤ i ≤ n) exists, such that a_i ≠ b_i holds.

Output

Output n space-separated integers p₁, p₂, ..., p_n, denoting a possible permutation Sengoku could have had. If there are more than one possible answer, output any one of them.

Input guarantees that such permutation exists.

Example

Input

5
1 2 3 4 3
1 2 5 4 5

Output

1 2 5 4 3

Input

5
4 4 2 3 1
5 4 5 3 1

Output

5 4 2 3 1

Input

4
1 1 3 4
1 4 3 4

Output

1 2 3 4

Note

In the first sample, both 1, 2, 5, 4, 3 and 1, 2, 3, 4, 5 are acceptable outputs.

In the second sample, 5, 4, 2, 3, 1 is the only permutation to satisfy the constraints.

题意：n个数，有两个序列，每个序列分别都有一个人看错了颜色（就是数字），求正确的序列（序列应该是1~n）n个数

思路 ：  第一种情况，若两个序列错得位置一样，则不同的个数为1，判断序列中还有那个值没有，放入失配的位置就可以

     第二种情况，若两个位置失配，则一定会是序列中一个位置的值是错，一个位置的值是对的，而且两个序列相同位置的值一定一个错一个对。。

  有个漏洞，刚开始我数组从下标0开始的，若第一个位置失配，他会赋值为0 因为这个错误，想了好久，没想出来，还是考虑不到啊。。。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int M=1100;
int a[M],b[M];
int n;
int p[M];
int vis[M];
struct node
{
    int pos;
    int x,y;
}v[3];
int main()
{
    while(~scanf("%d",&n))
    {
        int l=0;
        memset(vis,0,sizeof(vis));
        memset(p,0,sizeof(p));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&b[i]);
            if(a[i]==b[i])
            {
                p[i]=a[i];
                vis[a[i]]=1;
            }
        }

        for(int i=1;i<=n;i++)
        {
            if(a[i]!=b[i])
            {
                v[l].pos=i;
                v[l].x=a[i];
                v[l++].y=b[i];
            }
        }
        if(l==1)
        {
            int t;
            for(int i=1;i<=n;i++)
            {
                if(vis[i]==0)
                t=i;
            }
            for(int i=1;i<=n;i++)
            {
                if(p[i]==0)
                    p[i]=t;
            }
        }
        else
        {
            if(vis[a[v[0].pos]]==0&&vis[b[v[1].pos]]==0||vis[a[v[1].pos]])
            {
                p[v[0].pos]=a[v[0].pos];
                p[v[1].pos]=b[v[1].pos];
            }
            else
            {
                p[v[0].pos]=b[v[0].pos];
                p[v[1].pos]=a[v[1].pos];
            }
        }
        for(int i=1;i<=n-1;i++)
            printf("%d ",p[i]);
        printf("%d\n",p[n]);
    }
    return 0;
}