A permutation p of size n is the sequence p1, p2, ..., pn, consisting of n distinct integers, each of them is from 1 to n (1 ≤ pi ≤ n).

A lucky permutation is such permutation p, that any integer i (1 ≤ i ≤ n) meets this condition ppi = n - i + 1.

You have integer n. Find some lucky permutation p of size n.

Input

The first line contains integer n (1 ≤ n ≤ 105) — the required permutation size.

Output

Print "-1" (without the quotes) if the lucky permutation p of size n doesn't exist.

Otherwise, print n distinct integers p1, p2, ..., pn (1 ≤ pi ≤ n) after a space — the required permutation.

If there are multiple answers, you can print any of them.

Examples

Input

1


Output

1 


Input

2


Output

-1


Input

4


Output

2 4 1 3 


Input

5


Output

2 5 3 1 4 
import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.BigInteger;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;


public class Main
{
    static StringTokenizer st=new StringTokenizer("");
    static BufferedReader br;
    
    ///////////////////////////////////////////////////////////////////////////////////
    
    
    
    
    public static void main(String args[]) throws FileNotFoundException, IOException, Exception
    {
        //Scanner in =new Scanner(new FileReader("input.txt"));
        //PrintWriter out = new PrintWriter(new FileWriter("output.txt"));
        //Scanner in=new Scanner(System.in);
        br=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out=new PrintWriter(System.out);
        //StringTokenizer st;//=new StringTokenizer(br.readLine());
        int n=ni();
        int arr[]=new int[n+1];
        for(int i=n, j=1;i>0;i--,j++)
            arr[i]=j;
        int ans[]=new int[n+1];
        int max=2;
        if(n%4<2)
        {
            for(int i=1;i<=n/2;i+=2)
            {
                ans[i]=max;
                ans[ans[i]]=arr[i];
                ans[ans[ans[i]]]=arr[ans[i]];
                ans[ans[ans[ans[i]]]]=arr[ans[ans[i]]];
                max+=2;
            }
            if(n%2==1)
                ans[n/2+1]=n/2+1;
            for(int i=1;i<=n;i++)
                out.print(ans[i]+" ");
        }
        else out.print(-1);
	out.close();
    }
    
    
    
    
    ///////////////////////////////////////////////////////////////////////////////
    
    
    private static class pair implements Comparable<pair>
    {
        int ind;
        long first;
        long second;
        pair()
        {
            ind=0;
            first=0;
            second=0;
        }
        pair(int i,long f,long s)
        {
            ind =i;
            first=f;
            second=s;
        }

        public int compareTo(pair o)
        {
            if(first <  o.first)
                return 1;
            else if(first > o.first)
                return -1;
            else
                return 0;
        }
    }
    
    public static Integer ni() throws Exception
    {
        if(!st.hasMoreTokens())
            st=new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }
    public static BigInteger nb()throws Exception
    {
        if(!st.hasMoreElements())
            st=new StringTokenizer(br.readLine());
        return BigInteger.valueOf(Long.parseLong(st.nextToken()));
    }
    public static Long nl() throws Exception
    {
        if(!st.hasMoreTokens())
            st=new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }
    public static Double nd()throws Exception
    {
        if(!st.hasMoreElements())
            st=new StringTokenizer(br.readLine());
        return Double.parseDouble(st.nextToken());
    }
    public static String ns()throws Exception
    {
        if(!st.hasMoreElements())
            st=new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}