Problem: Piegirl found the red button. You have one last chance to change the inevitable end.

The circuit under the button consists of n nodes, numbered from 0 to n - 1. In order to deactivate the button, the n nodes must be disarmed in a particular order. Node 0 must be disarmed first. After disarming node i, the next node to be disarmed must be either node (2·i) modulo n or node (2·i) + 1 modulo n. The last node to be disarmed must be node 0. Node 0 must be disarmed twice, but all other nodes must be disarmed exactly once. 

Your task is to find any such order and print it. If there is no such order, print -1.

Input

Input consists of a single integer n (2 ≤ n ≤ 105).

Output

Print an order in which you can to disarm all nodes. If it is impossible, print -1 instead. If there are multiple orders, print any one of them.

Examples

Input

2


Output

0 1 0


Input

3


Output

-1

Input

4


Output

0 1 3 2 0


Input

16


Output

0 1 2 4 9 3 6 13 10 5 11 7 15 14 12 8 0

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
namespace fastIO {
template <typename T>
inline T read() {
  T f = 1, x = 0;
  char c = getchar();
  while (!isdigit(c)) {
    if (c == '-') f = -1;
    c = getchar();
  }
  while (isdigit(c)) {
    x = x * 10 + c - '0';
    c = getchar();
  }
  return x * f;
}
template <typename T>
inline void write(T x) {
  if (!x) {
    putchar('0');
    return;
  }
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  if (x > 9) write(x / 10);
  putchar(x % 10 + '0');
}
}  // namespace fastIO
using namespace fastIO;
namespace fastOutput {
template <typename T>
inline void print_char(T x, char ch) {
  write(x), putchar(ch);
}
template <typename T>
inline void char_print(char ch, T x) {
  putchar(ch);
  write(x);
}
template <typename T>
inline void print_space(T x) {
  print_char(x, ' ');
}
template <typename T>
inline void space_print(T x) {
  char_print(' ', x);
}
template <typename T>
inline void println(T x) {
  print_char(x, '\n');
}
template <typename T>
inline void lnprint(T x) {
  char_print('\n', x);
}
template <typename T>
inline void print_array1(T *a, int n) {
  for (int(i) = (1); (i) <= (n); ++(i)) print_char(a[i], " \n"[i == n]);
}
template <typename T>
inline void print_array2(T *a, int n) {
  println(n), print_array1(a, n);
}
template <typename T>
inline void print_array3(T *a, int n) {
  for (int(i) = (n); (i) >= (1); --(i)) print_char(a[i], " \n"[i == 1]);
}
template <typename T>
inline void print_array4(T *a, int n) {
  println(n), print_array3(a, n);
}
template <typename T>
inline void print_array_in_range1(T *a, int l, int r) {
  for (int(i) = (l); (i) <= (r); ++(i)) print_char(a[i], " \n"[i == r]);
}
template <typename T>
inline void print_array_in_range2(T *a, int l, int r) {
  for (int(i) = (r); (i) >= (l); --(i)) print_char(a[i], " \n"[i == l]);
}
template <typename T>
inline void print_array_in_range3(T *a, int l, int r) {
  for (int(i) = (l); (i) <= (r); ++(i)) println(a[i]);
}
template <typename T>
inline void print_array_in_range4(T *a, int l, int r) {
  for (int(i) = (r); (i) >= (l); --(i)) println(a[i]);
}
template <typename T>
inline void special_print_array1(T *a, int n) {
  print_space(n), print_array1(a, n);
}
template <typename T>
inline void special_print_array2(T *a, int n) {
  print_space(n), print_array3(a, n);
}
inline void print_string_in_range(string s, int l, int r) {
  for (int(i) = (l); (i) <= (r); ++(i)) putchar(s[i]);
}
inline void print_chars_in_range(char *a, int l, int r) {
  for (int(i) = (l); (i) <= (r); ++(i)) putchar(a[i]);
}
template <typename T>
inline void vector_print(vector<T> a, int l, int r) {
  for (int(i) = (l); (i) <= (r); ++(i)) print_char(a[i], " \n"[i == r]);
}
template <typename T>
inline void map_print(map<T, T> a, int l, int r) {
  for (int(i) = (l); (i) <= (r); ++(i)) print_char(a[i], " \n"[i == r]);
}
template <typename T>
inline void stack_print(stack<T> a) {
  while (!a.empty()) write(a.top()), a.pop();
}
template <typename T>
inline void queue_print(queue<T> a) {
  while (!a.empty()) write(a.front()), a.pop();
}
template <typename T>
inline void pq_print(priority_queue<T> a) {
  while (!a.empty()) write(a.top()), a.pop();
}
}  // namespace fastOutput
using namespace fastOutput;
const int N = 1e5 + 7;
int n, vis[N];
stack<int> q;
inline void dfs(int x) {
  if (vis[x]) return;
  vis[x] = 1, dfs((x * 2) % n), dfs((x * 2 + 1) % n), q.push(x);
}
int main() {
  n = read<int>();
  if (n & 1) return printf("-1"), 0;
  dfs(0);
  while (!q.empty()) print_space(q.top()), q.pop();
  return printf("0"), 0;
}