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.math.BigInteger;
import java.util.*;




public class A {
    private static final int mod = (int)1e9+7;
    
    boolean ok (final int[] xs) {
        for(int i = 0; i < xs.length; i++) {
            if(xs[xs[i]] != xs.length - 1 - i) {
                return false;
            }
        }
        return true;
    }

    int[] xs;
    void check(int a, int b) {
        xs[a] = b;
        for(int i = 0; i < xs.length; i++) {
            final int c = xs.length - 1 - xs[a];
//          System.err.println("2: " + Arrays.toString(xs) + " " + a + " " + b + " " + c);
            if(xs[c] == a) break;
            xs[c] = a;

            a = c;
        }
//      System.err.println(Arrays.toString(xs));
    }
    
    public void run() throws IOException {
        final int n = IOFast.nextInt();
        xs = new int[n];
        Arrays.fill(xs, -1);
        if(n == 1) { IOFast.out.println(1); return; }
        for(int i = n - 2, j = 0; i >= 0; i -= 2, j += 2) if(xs[i] == -1) {
            check(i, j);
        }
        if(n % 2 == 1) xs[n/2] = n/2;
        if(ok(xs)) {
            for(int j = 0; j < xs.length; j++) {
                IOFast.out.print(++xs[j] + (j == xs.length-1?"\n":" "));
            }
            return;
        }
        IOFast.out.println(-1);
        /*
        LOOP: for(int i = 1; i <= 10; i++) {
            IOFast.out.println("check: " + i);
            final int[] xs = new int[i];
            for(int j = 0; j < xs.length; j++) {
                xs[j] = j;
            }
            do {
                if(ok(xs)){
                    for(int j = 0; j < xs.length; j++) {
                        IOFast.out.print(xs[j] + " ");
                    }
                    IOFast.out.println();
                    continue LOOP;
                }
            } while(Permutation.nextPermutation(xs));
            IOFast.out.println("NOT FOUND");
        }
        */
    }
    
    static
    public class Permutation {
        private static final void swap(int[] xs, int i, int j) {
            final int t = xs[j];
            xs[j] = xs[i];
            xs[i] = t;
        }
        private static final boolean nextPermutation(final int[] xs) {
            for(int i = xs.length - 1; i > 0; i--) {
                if(xs[i - 1] > xs[i]) {
                    continue;
                }

                for(int j = i, k = xs.length - 1; j < k; j++, k--) {
                    swap(xs, j, k);
                }

                for(int j = i; j < xs.length; j++) if(xs[j] > xs[i - 1]) {
                    swap(xs, j, i - 1);
                    break;
                }

                return true;
            }
            return false;
        }
    }

    
    public static void main(String[] args) throws IOException {
//      IOFast.setFileIO("input.txt", "output.txt");
        new A().run();
        IOFast.out.flush();
    }


    static public class IOFast {
        private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        private static PrintWriter out = new PrintWriter(System.out);

        static void setFileIO(String ins, String outs) throws IOException {
            try {
                in = new BufferedReader(new FileReader(ins));
                out = new PrintWriter(new FileWriter(outs));
            }
            catch(IOException e) {
                System.err.println(e);
                throw e;
            }
        }

        //      private static final int BUFFER_SIZE = 50 * 200000;
        private static int pos, readLen;
        private static final char[] buffer = new char[1024 * 8];
        private static final StringBuilder buf = new StringBuilder();
        private static boolean[] isDigit = new boolean[256];
        private static boolean[] isSpace = new boolean[256];

        static {
            for(int i = 0; i < 10; i++) {
                isDigit['0' + i] = true;
            }
            isDigit['-'] = true;
            isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true;
        }

        static boolean endInput;

        private static int read() throws IOException {
            if(readLen == -1) {
                return -1;
            }

            if(pos >= readLen) {
                readLen = in.read(buffer);
                pos = 0;

                if(readLen <= 0) {
                    return -1;
                }
            }

            return buffer[pos++];
        }

        private static int nextInt() throws IOException {
            boolean plus = false;
            int ret = 0;
            while(true) {
                final int c = read();

                if(c == -1) {
                    endInput = true;
                    return Integer.MIN_VALUE;
                }

                if(isDigit[c]) {
                    if(c != '-') {
                        plus = true;
                        ret = c - '0';
                    }
                    break;
                }
            }

            while(true) {
                final int c = read();
                if(c == -1 || !isDigit[c]) {
                    break;
                }
                ret = ret * 10 + c - '0';
            }

            return plus ? ret : -ret;
        }

        private static long nextLong() throws IOException {
            boolean plus = false;
            long ret = 0;
            while(true) {
                final int c = read();

                if(c == -1) {
                    endInput = true;
                    return Integer.MIN_VALUE;
                }

                if(isDigit[c]) {
                    if(c != '-') {
                        plus = true;
                        ret = c - '0';
                    }
                    break;
                }
            }

            while(true) {
                final int c = read();
                if(c == -1 || !isDigit[c]) {
                    break;
                }
                ret = ret * 10 + c - '0';
            }

            return plus ? ret : -ret;
        }

        private static char nextChar() throws IOException {
            while(true) {
                final int c = read();

                if(c == -1) {
                    endInput = true;
                    return '\0';
                }

                if(!isSpace[c]) {
                    return (char)c;
                }
            }
        }

        private static String next() throws IOException {
            buf.setLength(0);

            while(true) {
                final int c = read();

                if(c == -1) {
                    endInput = true;
                    return "-1";
                }

                if(!isSpace[c]) {
                    buf.append((char)c);
                    break;
                }
            }

            while(true) {
                final int c = read();

                if(c == -1 || isSpace[c]) {
                    break;
                }
                buf.append((char)c);
            }

            return buf.toString();
        }

        private static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

    }

}
