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.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Alex
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
	public void solve(int testNumber, InputReader in, OutputWriter out){
	    int n = in.ri();
		if (n == 1){
			out.printLine(1);
			return;
		}
		if (n % 4 == 2 || n % 4 == 3){
			out.printLine(-1);
			return;
		}
		if (n % 4 == 0){
			int[] res = new int[n];
			for(int i = 0; i < res.length; i+=2) {
				int index = -1;
				if (i < res.length/2) index = i;
				else index = (res.length - 1) - i;
				res[index] = i+2;
			}
			for(int i = res.length - 2; i >= 0; i-=2){
				int val = res.length - i - 1;
				int index = -1;
				if (i >= res.length/2) index = i;
				else index = res.length - i - 1;
				res[index] = val;
			}
//			if (!check(res)) throw new RuntimeException();
			for(int i : res) out.print(i + " ");
		}
		else{
			int[] res = new int[n];
			int cur = 2;
			for(int i = 0; i < res.length; i+=2) {
				res[i] = cur;
				cur += 2;
				if (i == (res.length/2-2)) i+=2;
			}
			cur = 1;
			for(int i = res.length-2; i >= 0; i-=2){
				res[i] = cur;
				cur += 2;
				if (i == res.length/2+1 || i == res.length/2) i++;
			}
//			if (!check(res)) throw new RuntimeException();
			for(int i : res) out.print(i + " ");
		}

//		for(int length = 1; length <= 13; length++) {
//		    int[] temp = new int[length];
//		    for(int i = 0; i < temp.length; i++) temp[i] = i + 1;
//		    while(true){
//			    if (check(temp)) {
//				    out.printLine(length, Arrays.toString(temp));
//				    break;
//			    }
//			    if(!ArrayUtils.nextPermutation(temp)) break;
//		    }
//	    }
    }
}

class InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}
	public int ri(){
		return readInt();
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}
	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}
	public void close() {
		writer.close();
	}
	public void printLine(int i) {
		writer.println(i);
	}

}

