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.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;


public class C {
    
    static StringTokenizer st;
    static BufferedReader in;
    static PrintWriter pw;
    
    public static void main(String[] args) throws IOException {
        in = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n = nextInt();
        if (n==1) {
            System.out.println(1);
            return;
        }
        if (n % 4==2 || n % 4==3)
            System.out.println(-1);
        else {
            int min = 1, max = n;
            int[]ans = new int[n+1];
            int left = 1, right = n;
            for (int i = 1; i <= n/4; i++) {
                ans[left] = min+1;
                ans[left+1] = max;
                ans[right] = max-1;
                ans[right-1] = min;
                min += 2;
                max -= 2;
                left += 2;
                right -= 2;
            }
            if (n % 2==1)
                ans[n/2+1] = n/2+1;
            for (int i = 1; i <= n; i++) {
                pw.print(ans[i]+" ");
            }
            pw.println();
        }
//      int[]p = new int[n+1];
//      for (int i = 1; i <= n; i++) {
//          p[i] = i;
//      }
//      while (true) {
//          boolean f = true;
//          for (int i = 1; i <= n; i++) {
//              if (p[p[i]] != n-i+1) {
//                  f  = false;
//                  break;
//              }
//          }
//          if (f) {
//              for (int i = 1; i <= n; i++) {
//                  System.out.print(p[i]+" ");
//              }
//              return;
//          }
//          int ind1 = n;
//          while (ind1 > 1 && p[ind1] < p[ind1-1])
//              ind1--;
//          if (ind1==1)
//              break;
//          int ind2 = n;
//          while (p[ind2] < p[ind1-1])
//              ind2--;
//          int t = p[ind1-1];
//          p[ind1-1] = p[ind2];
//          p[ind2] = t;
//          for (int i = 0; i+ind1 < n-i; i++) {
//              t = p[ind1+i];
//              p[ind1+i] = p[n-i];
//              p[n-i] = t;
//          }
//      }
        pw.close();
    }
    private static int nextInt() throws IOException{
        return Integer.parseInt(next());
    }
    
    private static long nextLong() throws IOException{
        return Long.parseLong(next());
    }
    
    private static double nextDouble() throws IOException{
        return Double.parseDouble(next());
    }
    
    private static String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
}
/*
8
2 8 4 6 3 5 1 7 
9
2 9 4 7 5 3 6 1 8 


*/