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.math.*;

public class A implements Runnable {
	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer st;
	static Random rnd;

	void solve() throws IOException {
		int n = nextInt();

		if (n == 1) {
			out.println(1);
		} else if (n == 2) {
			out.println(-1);
		} else {
			int startFrom = n - 2;

			int[] p = new int[n];

			solve(n, p, startFrom);

			if (n % 2 != 0) {
				p[n / 2] = (n / 2);
			}

			if (!check(n, p)) {
				out.println(-1);
			} else {
				for (int i = 0; i < n; i++) {
					out.print(p[i] + 1);
					out.print((i + 1) == n ? "\n" : " ");
				}
			}

			// rec(0, n, new int[n], new boolean[n]);
		}
	}

	private void rec(int step, int n, int[] h, boolean[] u) {
		if (step == n) {
			if (check(n, h)) {
				out.println(Arrays.toString(h));
				out.flush();
			}
		} else {
			for (int i = 0; i < n; i++) {
				if (!u[i]) {
					h[step] = i;
					u[i] = true;
					rec(step + 1, n, h, u);
					u[i] = false;
				}
			}
		}
	}

	private void solve(int n, int[] p, int ptr) {
		int needSum = n - 1;

		int l = 0, r = n - 1;
		int first = 1, last = n - 1;

		while (l + 1 < r - 1) {
			p[l] = first;
			p[l + 1] = last;
			p[r] = needSum - first;
			p[r - 1] = needSum - last;
			first += 2;
			last -= 2;

			l += 2;
			r -= 2;
		}
	}

	private boolean check(int n, int[] p) {
		for (int i = 0; i < n; i++) {
			if (p[p[i]] != n - i - 1) {
				// out.println(i + " " + p[i] + " " + p[p[i]] + " " + (n - i -
				// 1));
				// out.flush();
				return false;
			}
		}
		return true;
	}

	public static void main(String[] args) {
		new A().run();
	}

	public void run() {
		try {
			final String className = this.getClass().getName().toLowerCase();

			try {
				in = new BufferedReader(new FileReader(className + ".in"));
				out = new PrintWriter(new FileWriter(className + ".out"));
				// in = new BufferedReader(new FileReader("input.txt"));
				// out = new PrintWriter(new FileWriter("output.txt"));
			} catch (FileNotFoundException e) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			}

			rnd = new Random();

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(42);
		}
	}

	String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String line = in.readLine();

			if (line == null)
				return null;

			st = new StringTokenizer(line);
		}

		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}