import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(3);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(1);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse") || in.equals("are you serious?") || in.equals("go die in a hole") || in.equals("terrible") || in.equals("no way") || in.equals("don't even")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}s
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(7);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse") || in.equals("are you serious?") || in.equals("go die in a hole") || in.equals("terrible") || in.equals("no way") || in.equals("don't even")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}s
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(8);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse") || in.equals("are you serious?") || in.equals("go die in a hole") || in.equals("terrible") || in.equals("no way") || in.equals("don't even")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}s
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class B {

	public static void main(String[] args)  {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		out.println(3);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class B {

	public static void main(String[] args)  {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		out.println(1);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class B {

	public static void main(String[] args)  {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		out.println(2);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(6);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse") || in.equals("are you serious?") || in.equals("go die in a hole") || in.equals("terrible") || in.equals("no way") || in.equals("don't even")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}s
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(2);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(0);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(9);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(0);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse") || in.equals("are you serious?") || in.equals("go die in a hole") || in.equals("terrible") || in.equals("no way") || in.equals("don't even")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}s
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(7);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class B {

	public static void main(String[] args)  {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		out.println(0);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(1);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(5);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


import java.io.PrintWriter;
import java.util.Scanner;

public class B {

	public static void main(String[] args)  {
//		FastScanner scan = new FastScanner();
		Scanner scan = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		out.println(2);
		out.flush();
		String in = scan.nextLine();
		if(in.equals("worse") || in.equals("are you serious?") || in.equals("go die in a hole") || in.equals("terrible") || in.equals("no way") || in.equals("don't even")) out.println("grumpy");
		else out.print("normal");
		out.close();
	}

//	static class FastScanner {
//		BufferedReader br;
//		StringTokenizer st;
//
//		public FastScanner() {
//			try	{
//				br = new BufferedReader(new InputStreamReader(System.in));
//				st = new StringTokenizer(br.readLine());
//			} catch (Exception e){e.printStackTrace();}s
//		}
//
//		public String next() {
//			if (st.hasMoreTokens())	return st.nextToken();
//			try {st = new StringTokenizer(br.readLine());}
//			catch (Exception e) {e.printStackTrace();}
//			return st.nextToken();
//		}
//
//		public int nextInt() {return Integer.parseInt(next());}
//
//		public long nextLong() {return Long.parseLong(next());}
//
//		public double nextDouble() {return Double.parseDouble(next());}
//
//		public String nextLine() {
//			String line = "";
//			if(st.hasMoreTokens()) line = st.nextToken();
//			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
//			while(st.hasMoreTokens()) line += " "+st.nextToken();
//			return line;
//		}
//
//		public int[] nextIntArray(int n) {
//			int[] a = new int[n];
//			for(int i = 0; i < n; i++) a[i] = nextInt();
//			return a;
//		}
//
//		public long[] nextLongArray(int n){
//			long[] a = new long[n];
//			for(int i = 0; i < n; i++) a[i] = nextLong();
//			return a;
//		}
//
//		public double[] nextDoubleArray(int n){
//			double[] a = new double[n];
//			for(int i = 0; i < n; i++) a[i] = nextDouble();
//			return a;
//		}
//
//		public char[][] nextGrid(int n, int m){
//			char[][] grid = new char[n][m];
//			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
//			return grid;
//		}
//	}

}


#include <bits/stdc++.h>
#include <iostream>
#define ll long long int
#define ld long double
#define pb push_back
#define mk make_pair
#define ff first
#define ss second
#define mod 998244353
#define INF 1e9
#define all(a) (a).begin(),(a).end()
#define fastread ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
typedef pair<int,int> pt;
int a[100005];
void unsort(int l, int r, int& k)
{
    if (k < 1 || l + 1 == r)
        return;

    // We make two recursive calls, so
    // reduce k by 2.
    k -= 2;

    int mid = (l + r) / 2;
    swap(a[mid - 1], a[mid]);
    unsort(l, mid, k);
    unsort(mid, r, k);
}

void arrayWithKCalls(int n, int k)
{
    if (k % 2 == 0) {
        cout <<"-1"<<endl;
        return;
    }

    a[0] = 1;
    for (int i = 1; i < n; i++)
        a[i] = i + 1;
    k--;

    unsort(0, n, k);

    for (int i = 0; i < n; ++i)
        cout << a[i] <<" ";
    cout<<endl;
}

int main()
{
    fastread;

    int n,k;
    cin>>n>>k;

    arrayWithKCalls(n,k);

    return 0;
}


#include <bits/stdc++.h>
#include <iostream>
#define ll long long int
#define ld long double
#define pb push_back
#define mk make_pair
#define ff first
#define ss second
#define mod 998244353
#define INF 1e9
#define all(a) (a).begin(),(a).end()
#define fastread ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
typedef pair<int,int> pt;

void unsort(int l, int r, int a[], int& k)
{
    if (k < 1 || l + 1 == r)
        return;

    // We make two recursive calls, so
    // reduce k by 2.
    k -= 2;

    int mid = (l + r) / 2;
    swap(a[mid - 1], a[mid]);
    unsort(l, mid, a, k);
    unsort(mid, r, a, k);
}

void arrayWithKCalls(int n, int k)
{
    if (k % 2 == 0) {
        cout <<"-1";
        return;
    }
    int a[n+1];
    a[0] = 1;
    for (int i = 1; i < n; i++)
        a[i] = i + 1;
    k--;

    // calling unsort function
    unsort(0, n, a, k);

    for (int i = 0; i < n; ++i)
        cout << a[i] << ' ';
}

int main()
{
    fastread;

    int n,k;
    cin>>n>>k;

    arrayWithKCalls(n,k);

    return 0;
}


#include <bits/stdc++.h>
#include <iostream>
#define ll long long int
#define ld long double
#define pb push_back
#define mk make_pair
#define ff first
#define ss second
#define mod 998244353
#define INF 1e9
#define all(a) (a).begin(),(a).end()
#define fastread ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
typedef pair<int,int> pt;
int a[100005];
void unsort(int l, int r, int& k)
{
    if (k < 1 || l + 1 == r)
        return;
    k -= 2;

    int mid = (l + r) / 2;
    swap(a[mid - 1], a[mid]);
    unsort(l, mid, k);
    unsort(mid, r, k);
}

void arrayWithKCalls(int n, int k)
{
    if (k%2 == 0||(k>(2*(2*n+1)-1)))
    {   cout <<"-1"<<endl;
        return;
    }

    a[0] = 1;
    for (int i = 1; i < n; i++)
        a[i] = i + 1;
    k--;

    unsort(0, n, k);

    for (int i = 0; i < n; ++i)
        cout << a[i] <<" ";
    cout<<endl;
}

int main()
{
    fastread;

    int n,k;
    cin>>n>>k;

    arrayWithKCalls(n,k);

    return 0;
}


#include <bits/stdc++.h>
#include <iostream>
#define ll long long int
#define ld long double
#define pb push_back
#define mk make_pair
#define ff first
#define ss second
#define mod 998244353
#define INF 1e9
#define all(a) (a).begin(),(a).end()
#define fastread ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
typedef pair<int,int> pt;
int a[100005];
void unsort(int l, int r, int& k)
{
    if (k < 1 || l + 1 == r)
        return;
    k -= 2;
    int mid = (l + r) / 2;
    swap(a[mid - 1], a[mid]);
    unsort(l, mid, k);
    unsort(mid, r, k);
}

void arrayWithKCalls(int n, int k)
{
    if (k%2 == 0)
    {   cout <<"-1"<<endl;
        return;
    }

    a[0] = 1;
    for (int i = 1; i < n; i++)
        a[i] = i + 1;
    k--;

    unsort(0, n, k);

    if(k<0)
    {
        cout<<"-1"<<endl;
        return;
    }
    for (int i = 0; i < n; ++i)
        cout<<a[i]<<" ";
    cout<<endl;
}

int main()
{
    fastread;

    int n,k;
    cin>>n>>k;

    arrayWithKCalls(n,k);

    return 0;
}


/*
    Tushar Pahuja
    Vellore Institute of Technology Chennai
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> //Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
using namespace __gnu_pbds;

#define gc getchar_unlocked

#define ll long long
#define ull unsigned long long
#define ld long double

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef pair<int, int>	pi;
typedef pair<ll, ll>	pll;
typedef vector<int>		vi;
typedef vector<ll>		vll;
typedef vector<pi>		vpi;
typedef vector<pll>		vpll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvl;
typedef
tree<
  pair<ll,ll>,
  null_type,
  greater<pair<ll,ll> >,
  rb_tree_tag,
  tree_order_statistics_node_update>
main_ds;

#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define sub(a,b) a-b
#define orr(a,b) a||b
#define si(x)	scanf("%d",&x)
#define sl(x)	scanf("%lld",&x)
#define ss(s)	scanf("%s",s)
#define pi(x)	printf("%d\n",x)
#define pl(x)	printf("%lld\n",x)
#define ps(s)	printf("%s\n",s)
#define slen(s) strlen(s)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define boostIO ios_base::sync_with_stdio(false), cin.tie(0)
#define tc(t) ll t; cin >> t; while(t--)
#define PI 3.1415926535897932384626
#define beg int main()
#define ret return 0
#define bye exit(0)
#define nxl <<endl
#define show cout<<
#define INF 0x3f3f3f3f
#define MAX 200000
#define mod 1000000007

ll power2(ll a, ll b) { if(b == 0) return 1; if(b == 1) return a; ll x = power2(a, b / 2); x = x * x; if(b % 2) x = x * a; return x;}
ll gcd(ll a, ll b) {if(a < b) swap(a, b); while(b) {ll t = b; b = a % b; a = t;} return a;}
ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m;}
ll add(ll a, ll b, ll m = mod) { a += b; if(a >= m) a -= m; if(a < 0) a += m; return a;}

ll power(ll a, ll b, ll m = mod) { if(b == 0) return 1; if(b == 1) return (a % m); ll x = power(a, b / 2, m); x = mul(x, x, m); if(b % 2) x = mul(x, a, m); return x;}

int readline( char * str ) {int i = 0;char ch;while ( (ch = getchar() ) != '\n' ) {str[i++] = ch;}str[i] = '\0';return i;}

//struct HASH{
//  size_t operator()(const pair<ll,ll>&x)const{
//    return hash<ll>()(((ll)x.first)^(((ll)x.second)<<64));
//  }
//};

// ll bin_ser(ll low,ll high,ll key){

//    while(low<=high){
//        ll mid = (low+high)/2;
//        if(v1[mid]<key){
//            low = mid+1;
//        }
//        else if(v1[mid]>key){
//            high = mid-1;
//        }
//        else{
//            return (mid+1);
//        }
//    }
//    return -1;
// }

//bool dfs(const vector<vector<int>>& a, vector<char>& used, int v) {
//    used[v] = 1;
//    for (int x : a[v]) {
//        if (used[x] == 1) {
//            return false;
//        } else if (used[x] == 0) {
//            if (!dfs(a, used, x)) {
//                return false;
//            }
//        }
//    }
//    used[v] = 2;
//    return true;
//}
//
//bool ensure_absence_of_cycles(const vector<vector<int>>& a) {
//    int n = a.size();
//    vector<char> used(n);
//    for (int i = 0; i < n; ++i) {
//        if (!used[i]) {
//            if (!dfs(a, used, i)) {
//                return false;
//            }
//        }
//    }
//    return true;
//}
//
//

bool yoyo(const ll p1 ,const ll p2){
    return p1 > p2;
}

vll arr;
ll n,k;

void unsort(ll l,ll r){
    if(l==r) return;
    if(k){
        k -= 2;
        ll mid = ceil((l+r)/2);
        swap(arr[mid],arr[mid-51]);
        unsort(l,mid);
        unsort(mid+1,r);
    }

}

beg{

ll t,a,b,c,d,e,f,i,j,l,x,y,z,m;

//debug2(a,b);
cin >> n >> k;

fo(i,n){
    arr.pb(i+1);
}

if(k%2==0){
    cout<<-1<<endl;
    bye;
}

k--;
unsort(0,n-1);

if(k){
    cout<<-1<<endl;
    bye;
}
else{
    fo(i,arr.size()){
        cout<<arr[i]<<" ";
    }
}
ret;
}


/*
    Tushar Pahuja
    Vellore Institute of Technology Chennai
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> //Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
using namespace __gnu_pbds;

#define gc getchar_unlocked

#define ll long long
#define ull unsigned long long
#define ld long double

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef pair<int, int>	pi;
typedef pair<ll, ll>	pll;
typedef vector<int>		vi;
typedef vector<ll>		vll;
typedef vector<pi>		vpi;
typedef vector<pll>		vpll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvl;
typedef
tree<
  pair<ll,ll>,
  null_type,
  greater<pair<ll,ll> >,
  rb_tree_tag,
  tree_order_statistics_node_update>
main_ds;

#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define sub(a,b) a-b
#define orr(a,b) a||b
#define si(x)	scanf("%d",&x)
#define sl(x)	scanf("%lld",&x)
#define ss(s)	scanf("%s",s)
#define pi(x)	printf("%d\n",x)
#define pl(x)	printf("%lld\n",x)
#define ps(s)	printf("%s\n",s)
#define slen(s) strlen(s)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define boostIO ios_base::sync_with_stdio(false), cin.tie(0)
#define tc(t) ll t; cin >> t; while(t--)
#define PI 3.1415926535897932384626
#define beg int main()
#define ret return 0
#define bye exit(0)
#define nxl <<endl
#define show cout<<
#define INF 0x3f3f3f3f
#define MAX 200000
#define mod 1000000007

ll power2(ll a, ll b) { if(b == 0) return 1; if(b == 1) return a; ll x = power2(a, b / 2); x = x * x; if(b % 2) x = x * a; return x;}
ll gcd(ll a, ll b) {if(a < b) swap(a, b); while(b) {ll t = b; b = a % b; a = t;} return a;}
ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m;}
ll add(ll a, ll b, ll m = mod) { a += b; if(a >= m) a -= m; if(a < 0) a += m; return a;}

ll power(ll a, ll b, ll m = mod) { if(b == 0) return 1; if(b == 1) return (a % m); ll x = power(a, b / 2, m); x = mul(x, x, m); if(b % 2) x = mul(x, a, m); return x;}

int readline( char * str ) {int i = 0;char ch;while ( (ch = getchar() ) != '\n' ) {str[i++] = ch;}str[i] = '\0';return i;}

//struct HASH{
//  size_t operator()(const pair<ll,ll>&x)const{
//    return hash<ll>()(((ll)x.first)^(((ll)x.second)<<64));
//  }
//};

// ll bin_ser(ll low,ll high,ll key){

//    while(low<=high){
//        ll mid = (low+high)/2;
//        if(v1[mid]<key){
//            low = mid+1;
//        }
//        else if(v1[mid]>key){
//            high = mid-1;
//        }
//        else{
//            return (mid+1);
//        }
//    }
//    return -1;
// }

//bool dfs(const vector<vector<int>>& a, vector<char>& used, int v) {
//    used[v] = 1;
//    for (int x : a[v]) {
//        if (used[x] == 1) {
//            return false;
//        } else if (used[x] == 0) {
//            if (!dfs(a, used, x)) {
//                return false;
//            }
//        }
//    }
//    used[v] = 2;
//    return true;
//}
//
//bool ensure_absence_of_cycles(const vector<vector<int>>& a) {
//    int n = a.size();
//    vector<char> used(n);
//    for (int i = 0; i < n; ++i) {
//        if (!used[i]) {
//            if (!dfs(a, used, i)) {
//                return false;
//            }
//        }
//    }
//    return true;
//}
//
//

bool yoyo(const ll p1 ,const ll p2){
    return p1 > p2;
}

vll arr;
ll n,k;

void unsort(ll l,ll r){
    if(l==r) return;
    if(k){
        k -= 2;
        ll mid = (l+r)/2;
        swap(arr[mid],arr[mid+1]);
        unsort(l,mid);
        unsort(mid+1,r);
    }

}

beg{

ll t,a,b,c,d,e,f,i,j,l,x,y,z,m;

//debug2(a,b);
cin >> n >> k;

fo(i,n){
    arr.pb(i+1);
}

if(k%2==0){
    cout<<-1<<endl;
    bye;
}

k--;
unsort(0,n-1);

if(k){
    cout<<-1<<endl;
    bye;
}
else{
    fo(i,arr.size()){
        cout<<arr[i]<<" ";
    }
}
ret;
}


/*
    Tushar Pahuja
    Vellore Institute of Technology Chennai
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> //Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
using namespace __gnu_pbds;

#define gc getchar_unlocked

#define ll long long
#define ull unsigned long long
#define ld long double

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef pair<int, int>	pi;
typedef pair<ll, ll>	pll;
typedef vector<int>		vi;
typedef vector<ll>		vll;
typedef vector<pi>		vpi;
typedef vector<pll>		vpll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvl;
typedef
tree<
  pair<ll,ll>,
  null_type,
  greater<pair<ll,ll> >,
  rb_tree_tag,
  tree_order_statistics_node_update>
main_ds;

#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define sub(a,b) a-b
#define orr(a,b) a||b
#define si(x)	scanf("%d",&x)
#define sl(x)	scanf("%lld",&x)
#define ss(s)	scanf("%s",s)
#define pi(x)	printf("%d\n",x)
#define pl(x)	printf("%lld\n",x)
#define ps(s)	printf("%s\n",s)
#define slen(s) strlen(s)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define boostIO ios_base::sync_with_stdio(false), cin.tie(0)
#define tc(t) ll t; cin >> t; while(t--)
#define PI 3.1415926535897932384626
#define beg int main()
#define ret return 0
#define bye exit(0)
#define nxl <<endl
#define show cout<<
#define INF 0x3f3f3f3f
#define MAX 200000
#define mod 1000000007

ll power2(ll a, ll b) { if(b == 0) return 1; if(b == 1) return a; ll x = power2(a, b / 2); x = x * x; if(b % 2) x = x * a; return x;}
ll gcd(ll a, ll b) {if(a < b) swap(a, b); while(b) {ll t = b; b = a % b; a = t;} return a;}
ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m;}
ll add(ll a, ll b, ll m = mod) { a += b; if(a >= m) a -= m; if(a < 0) a += m; return a;}

ll power(ll a, ll b, ll m = mod) { if(b == 0) return 1; if(b == 1) return (a % m); ll x = power(a, b / 2, m); x = mul(x, x, m); if(b % 2) x = mul(x, a, m); return x;}

int readline( char * str ) {int i = 0;char ch;while ( (ch = getchar() ) != '\n' ) {str[i++] = ch;}str[i] = '\0';return i;}

//struct HASH{
//  size_t operator()(const pair<ll,ll>&x)const{
//    return hash<ll>()(((ll)x.first)^(((ll)x.second)<<64));
//  }
//};

// ll bin_ser(ll low,ll high,ll key){

//    while(low<=high){
//        ll mid = (low+high)/2;
//        if(v1[mid]<key){
//            low = mid+1;
//        }
//        else if(v1[mid]>key){
//            high = mid-1;
//        }
//        else{
//            return (mid+1);
//        }
//    }
//    return -1;
// }

//bool dfs(const vector<vector<int>>& a, vector<char>& used, int v) {
//    used[v] = 1;
//    for (int x : a[v]) {
//        if (used[x] == 1) {
//            return false;
//        } else if (used[x] == 0) {
//            if (!dfs(a, used, x)) {
//                return false;
//            }
//        }
//    }
//    used[v] = 2;
//    return true;
//}
//
//bool ensure_absence_of_cycles(const vector<vector<int>>& a) {
//    int n = a.size();
//    vector<char> used(n);
//    for (int i = 0; i < n; ++i) {
//        if (!used[i]) {
//            if (!dfs(a, used, i)) {
//                return false;
//            }
//        }
//    }
//    return true;
//}
//
//

bool yoyo(const ll p1 ,const ll p2){
    return p1 > p2;
}

vll arr;
ll n,k;

void unsort(ll l,ll r){
    if(l==r) return;
    if(k){
        k -= 2;
        ll mid = (l+r)/2;
        unsort(l,mid);
        unsort(mid+1,r);
    }
    else{
        sort(arr.begin()+l,arr.begin()+r+1);
    }

}

beg{

ll t,a,b,c,d,e,f,i,j,l,x,y,z,m;

//debug2(a,b);
cin >> n >> k;

for(i=n;i>=1;i--){
    arr.pb(i);
}

if(k%2==0){
    cout<<-1<<endl;
    bye;
}

k--;
unsort(0,n-1);

if(k){
    cout<<-1<<endl;
    bye;
}
else{
    fo(i,arr.size()){
        cout<<arr[i]<<" ";
    }
}
ret;
}


/*
    Tushar Pahuja
    Vellore Institute of Technology Chennai
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> //Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
using namespace __gnu_pbds;

#define gc getchar_unlocked

#define ll long long
#define ull unsigned long long
#define ld long double

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef pair<int, int>	pi;
typedef pair<ll, ll>	pll;
typedef vector<int>		vi;
typedef vector<ll>		vll;
typedef vector<pi>		vpi;
typedef vector<pll>		vpll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvl;
typedef
tree<
  pair<ll,ll>,
  null_type,
  greater<pair<ll,ll> >,
  rb_tree_tag,
  tree_order_statistics_node_update>
main_ds;

#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define sub(a,b) a-b
#define orr(a,b) a||b
#define si(x)	scanf("%d",&x)
#define sl(x)	scanf("%lld",&x)
#define ss(s)	scanf("%s",s)
#define pi(x)	printf("%d\n",x)
#define pl(x)	printf("%lld\n",x)
#define ps(s)	printf("%s\n",s)
#define slen(s) strlen(s)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define boostIO ios_base::sync_with_stdio(false), cin.tie(0)
#define tc(t) ll t; cin >> t; while(t--)
#define PI 3.1415926535897932384626
#define beg int main()
#define ret return 0
#define bye exit(0)
#define nxl <<endl
#define show cout<<
#define INF 0x3f3f3f3f
#define MAX 200000
#define mod 1000000007

ll power2(ll a, ll b) { if(b == 0) return 1; if(b == 1) return a; ll x = power2(a, b / 2); x = x * x; if(b % 2) x = x * a; return x;}
ll gcd(ll a, ll b) {if(a < b) swap(a, b); while(b) {ll t = b; b = a % b; a = t;} return a;}
ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m;}
ll add(ll a, ll b, ll m = mod) { a += b; if(a >= m) a -= m; if(a < 0) a += m; return a;}

ll power(ll a, ll b, ll m = mod) { if(b == 0) return 1; if(b == 1) return (a % m); ll x = power(a, b / 2, m); x = mul(x, x, m); if(b % 2) x = mul(x, a, m); return x;}

int readline( char * str ) {int i = 0;char ch;while ( (ch = getchar() ) != '\n' ) {str[i++] = ch;}str[i] = '\0';return i;}

//struct HASH{
//  size_t operator()(const pair<ll,ll>&x)const{
//    return hash<ll>()(((ll)x.first)^(((ll)x.second)<<64));
//  }
//};

// ll bin_ser(ll low,ll high,ll key){

//    while(low<=high){
//        ll mid = (low+high)/2;
//        if(v1[mid]<key){
//            low = mid+1;
//        }
//        else if(v1[mid]>key){
//            high = mid-1;
//        }
//        else{
//            return (mid+1);
//        }
//    }
//    return -1;
// }

//bool dfs(const vector<vector<int>>& a, vector<char>& used, int v) {
//    used[v] = 1;
//    for (int x : a[v]) {
//        if (used[x] == 1) {
//            return false;
//        } else if (used[x] == 0) {
//            if (!dfs(a, used, x)) {
//                return false;
//            }
//        }
//    }
//    used[v] = 2;
//    return true;
//}
//
//bool ensure_absence_of_cycles(const vector<vector<int>>& a) {
//    int n = a.size();
//    vector<char> used(n);
//    for (int i = 0; i < n; ++i) {
//        if (!used[i]) {
//            if (!dfs(a, used, i)) {
//                return false;
//            }
//        }
//    }
//    return true;
//}
//
//

bool yoyo(const ll p1 ,const ll p2){
    return p1 > p2;
}

vll arr;
ll n,k;

void unsort(ll l,ll r){
    if(l==r) return;
    if(k){
        k -= 2;
        ll mid = (l+r)/2;
        swap(arr[mid],arr[mid-1]);
        unsort(l,mid);
        unsort(mid+1,r);
    }

}

beg{

ll t,a,b,c,d,e,f,i,j,l,x,y,z,m;

//debug2(a,b);
cin >> n >> k;

fo(i,n){
    arr.pb(i+1);
}

if(k%2==0){
    cout<<-1<<endl;
    bye;
}

k--;
unsort(0,n-1);

if(k){
    cout<<-1<<endl;
    bye;
}
else{
    fo(i,arr.size()){
        cout<<arr[i]<<" ";
    }
}
ret;
}


/*
    Tushar Pahuja
    Vellore Institute of Technology Chennai
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> //Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
using namespace __gnu_pbds;

#define gc getchar_unlocked

#define ll long long
#define ull unsigned long long
#define ld long double

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef pair<int, int>	pi;
typedef pair<ll, ll>	pll;
typedef vector<int>		vi;
typedef vector<ll>		vll;
typedef vector<pi>		vpi;
typedef vector<pll>		vpll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvl;
typedef
tree<
  pair<ll,ll>,
  null_type,
  greater<pair<ll,ll> >,
  rb_tree_tag,
  tree_order_statistics_node_update>
main_ds;

#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define sub(a,b) a-b
#define orr(a,b) a||b
#define si(x)	scanf("%d",&x)
#define sl(x)	scanf("%lld",&x)
#define ss(s)	scanf("%s",s)
#define pi(x)	printf("%d\n",x)
#define pl(x)	printf("%lld\n",x)
#define ps(s)	printf("%s\n",s)
#define slen(s) strlen(s)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define boostIO ios_base::sync_with_stdio(false), cin.tie(0)
#define tc(t) ll t; cin >> t; while(t--)
#define PI 3.1415926535897932384626
#define beg int main()
#define ret return 0
#define bye exit(0)
#define nxl <<endl
#define show cout<<
#define INF 0x3f3f3f3f
#define MAX 200000
#define mod 1000000007

ll power2(ll a, ll b) { if(b == 0) return 1; if(b == 1) return a; ll x = power2(a, b / 2); x = x * x; if(b % 2) x = x * a; return x;}
ll gcd(ll a, ll b) {if(a < b) swap(a, b); while(b) {ll t = b; b = a % b; a = t;} return a;}
ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m;}
ll add(ll a, ll b, ll m = mod) { a += b; if(a >= m) a -= m; if(a < 0) a += m; return a;}

ll power(ll a, ll b, ll m = mod) { if(b == 0) return 1; if(b == 1) return (a % m); ll x = power(a, b / 2, m); x = mul(x, x, m); if(b % 2) x = mul(x, a, m); return x;}

int readline( char * str ) {int i = 0;char ch;while ( (ch = getchar() ) != '\n' ) {str[i++] = ch;}str[i] = '\0';return i;}

//struct HASH{
//  size_t operator()(const pair<ll,ll>&x)const{
//    return hash<ll>()(((ll)x.first)^(((ll)x.second)<<64));
//  }
//};

// ll bin_ser(ll low,ll high,ll key){

//    while(low<=high){
//        ll mid = (low+high)/2;
//        if(v1[mid]<key){
//            low = mid+1;
//        }
//        else if(v1[mid]>key){
//            high = mid-1;
//        }
//        else{
//            return (mid+1);
//        }
//    }
//    return -1;
// }

//bool dfs(const vector<vector<int>>& a, vector<char>& used, int v) {
//    used[v] = 1;
//    for (int x : a[v]) {
//        if (used[x] == 1) {
//            return false;
//        } else if (used[x] == 0) {
//            if (!dfs(a, used, x)) {
//                return false;
//            }
//        }
//    }
//    used[v] = 2;
//    return true;
//}
//
//bool ensure_absence_of_cycles(const vector<vector<int>>& a) {
//    int n = a.size();
//    vector<char> used(n);
//    for (int i = 0; i < n; ++i) {
//        if (!used[i]) {
//            if (!dfs(a, used, i)) {
//                return false;
//            }
//        }
//    }
//    return true;
//}
//
//

bool yoyo(const ll p1 ,const ll p2){
    return p1 > p2;
}

vll arr;
ll n,k;

void unsort(ll l,ll r){
    if(l==r) return;
    if(k){
        k -= 2;
        ll mid = (l+r-1)/2;
        unsort(l,mid);
        unsort(mid+1,r);
    }
    else{
        sort(arr.begin()+l,arr.begin()+r+1);
    }

}

beg{

ll t,a,b,c,d,e,f,i,j,l,x,y,z,m;

//debug2(a,b);
cin >> n >> k;

for(i=n;i>=1;i--){
    arr.pb(i);
}

if(k%2==0){
    cout<<-1<<endl;
    bye;
}

k--;
unsort(0,n-1);

if(k){
    cout<<-1<<endl;
    bye;
}
else{
    fo(i,arr.size()){
        cout<<arr[i]<<" ";
    }
}
ret;
}


/*
    Tushar Pahuja
    Vellore Institute of Technology Chennai
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> //Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
using namespace __gnu_pbds;

#define gc getchar_unlocked

#define ll long long
#define ull unsigned long long
#define ld long double

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef pair<int, int>	pi;
typedef pair<ll, ll>	pll;
typedef vector<int>		vi;
typedef vector<ll>		vll;
typedef vector<pi>		vpi;
typedef vector<pll>		vpll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvl;
typedef
tree<
  pair<ll,ll>,
  null_type,
  greater<pair<ll,ll> >,
  rb_tree_tag,
  tree_order_statistics_node_update>
main_ds;

#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define sub(a,b) a-b
#define orr(a,b) a||b
#define si(x)	scanf("%d",&x)
#define sl(x)	scanf("%lld",&x)
#define ss(s)	scanf("%s",s)
#define pi(x)	printf("%d\n",x)
#define pl(x)	printf("%lld\n",x)
#define ps(s)	printf("%s\n",s)
#define slen(s) strlen(s)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define boostIO ios_base::sync_with_stdio(false), cin.tie(0)
#define tc(t) ll t; cin >> t; while(t--)
#define PI 3.1415926535897932384626
#define beg int main()
#define ret return 0
#define bye exit(0)
#define nxl <<endl
#define show cout<<
#define INF 0x3f3f3f3f
#define MAX 200000
#define mod 1000000007

ll power2(ll a, ll b) { if(b == 0) return 1; if(b == 1) return a; ll x = power2(a, b / 2); x = x * x; if(b % 2) x = x * a; return x;}
ll gcd(ll a, ll b) {if(a < b) swap(a, b); while(b) {ll t = b; b = a % b; a = t;} return a;}
ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m;}
ll add(ll a, ll b, ll m = mod) { a += b; if(a >= m) a -= m; if(a < 0) a += m; return a;}

ll power(ll a, ll b, ll m = mod) { if(b == 0) return 1; if(b == 1) return (a % m); ll x = power(a, b / 2, m); x = mul(x, x, m); if(b % 2) x = mul(x, a, m); return x;}

int readline( char * str ) {int i = 0;char ch;while ( (ch = getchar() ) != '\n' ) {str[i++] = ch;}str[i] = '\0';return i;}

//struct HASH{
//  size_t operator()(const pair<ll,ll>&x)const{
//    return hash<ll>()(((ll)x.first)^(((ll)x.second)<<64));
//  }
//};

// ll bin_ser(ll low,ll high,ll key){

//    while(low<=high){
//        ll mid = (low+high)/2;
//        if(v1[mid]<key){
//            low = mid+1;
//        }
//        else if(v1[mid]>key){
//            high = mid-1;
//        }
//        else{
//            return (mid+1);
//        }
//    }
//    return -1;
// }

//bool dfs(const vector<vector<int>>& a, vector<char>& used, int v) {
//    used[v] = 1;
//    for (int x : a[v]) {
//        if (used[x] == 1) {
//            return false;
//        } else if (used[x] == 0) {
//            if (!dfs(a, used, x)) {
//                return false;
//            }
//        }
//    }
//    used[v] = 2;
//    return true;
//}
//
//bool ensure_absence_of_cycles(const vector<vector<int>>& a) {
//    int n = a.size();
//    vector<char> used(n);
//    for (int i = 0; i < n; ++i) {
//        if (!used[i]) {
//            if (!dfs(a, used, i)) {
//                return false;
//            }
//        }
//    }
//    return true;
//}
//
//

bool yoyo(const ll p1 ,const ll p2){
    return p1 > p2;
}

vll arr;
ll n,k;

void unsort(ll l,ll r){
    if(l==r) return;
    if(k){
        k -= 2;
        ll mid = (l+r)/2;
        unsort(l,mid-1);
        unsort(mid,r);
    }
    else{
        sort(arr.begin()+l,arr.begin()+r+1);
    }

}

beg{

ll t,a,b,c,d,e,f,i,j,l,x,y,z,m;

//debug2(a,b);
cin >> n >> k;

for(i=n;i>=1;i--){
    arr.pb(i);
}

if(k%2==0){
    cout<<-1<<endl;
    bye;
}

k--;
unsort(0,n-1);

if(k){
    cout<<-1<<endl;
    bye;
}
else{
    fo(i,arr.size()){
        cout<<arr[i]<<" ";
    }
}
ret;
}


/*
    Tushar Pahuja
    Vellore Institute of Technology Chennai
*/

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> //Including tree_order_statistics_node_update
#include <ext/pb_ds/detail/standard_policies.hpp>

using namespace std;
using namespace __gnu_pbds;

#define gc getchar_unlocked

#define ll long long
#define ull unsigned long long
#define ld long double

#define debug(x) cout<<#x<<" :: "<<x<<"\n";
#define debug2(x,y) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\n";
#define debug3(x,y,z) cout<<#x<<" :: "<<x<<"\t"<<#y<<" :: "<<y<<"\t"<<#z<<" :: "<<z<<"\n";

typedef pair<int, int>	pi;
typedef pair<ll, ll>	pll;
typedef vector<int>		vi;
typedef vector<ll>		vll;
typedef vector<pi>		vpi;
typedef vector<pll>		vpll;
typedef vector<vi>		vvi;
typedef vector<vll>		vvl;
typedef
tree<
  pair<ll,ll>,
  null_type,
  greater<pair<ll,ll> >,
  rb_tree_tag,
  tree_order_statistics_node_update>
main_ds;

#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define sub(a,b) a-b
#define orr(a,b) a||b
#define si(x)	scanf("%d",&x)
#define sl(x)	scanf("%lld",&x)
#define ss(s)	scanf("%s",s)
#define pi(x)	printf("%d\n",x)
#define pl(x)	printf("%lld\n",x)
#define ps(s)	printf("%s\n",s)
#define slen(s) strlen(s)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define boostIO ios_base::sync_with_stdio(false), cin.tie(0)
#define tc(t) ll t; cin >> t; while(t--)
#define PI 3.1415926535897932384626
#define beg int main()
#define ret return 0
#define bye exit(0)
#define nxl <<endl
#define show cout<<
#define INF 0x3f3f3f3f
#define MAX 200000
#define mod 1000000007

ll power2(ll a, ll b) { if(b == 0) return 1; if(b == 1) return a; ll x = power2(a, b / 2); x = x * x; if(b % 2) x = x * a; return x;}
ll gcd(ll a, ll b) {if(a < b) swap(a, b); while(b) {ll t = b; b = a % b; a = t;} return a;}
ll mul(ll a, ll b, ll m = mod) { return (ll)(a * b) % m;}
ll add(ll a, ll b, ll m = mod) { a += b; if(a >= m) a -= m; if(a < 0) a += m; return a;}

ll power(ll a, ll b, ll m = mod) { if(b == 0) return 1; if(b == 1) return (a % m); ll x = power(a, b / 2, m); x = mul(x, x, m); if(b % 2) x = mul(x, a, m); return x;}

int readline( char * str ) {int i = 0;char ch;while ( (ch = getchar() ) != '\n' ) {str[i++] = ch;}str[i] = '\0';return i;}

//struct HASH{
//  size_t operator()(const pair<ll,ll>&x)const{
//    return hash<ll>()(((ll)x.first)^(((ll)x.second)<<64));
//  }
//};

// ll bin_ser(ll low,ll high,ll key){

//    while(low<=high){
//        ll mid = (low+high)/2;
//        if(v1[mid]<key){
//            low = mid+1;
//        }
//        else if(v1[mid]>key){
//            high = mid-1;
//        }
//        else{
//            return (mid+1);
//        }
//    }
//    return -1;
// }

//bool dfs(const vector<vector<int>>& a, vector<char>& used, int v) {
//    used[v] = 1;
//    for (int x : a[v]) {
//        if (used[x] == 1) {
//            return false;
//        } else if (used[x] == 0) {
//            if (!dfs(a, used, x)) {
//                return false;
//            }
//        }
//    }
//    used[v] = 2;
//    return true;
//}
//
//bool ensure_absence_of_cycles(const vector<vector<int>>& a) {
//    int n = a.size();
//    vector<char> used(n);
//    for (int i = 0; i < n; ++i) {
//        if (!used[i]) {
//            if (!dfs(a, used, i)) {
//                return false;
//            }
//        }
//    }
//    return true;
//}
//
//

bool yoyo(const ll p1 ,const ll p2){
    return p1 > p2;
}

vll arr;
ll n,k;

void unsort(ll l,ll r){
    if(l==r) return;
    if(k){
        k -= 2;
        ll mid = ceil((l+r)/2);
        swap(arr[mid],arr[mid-1]);
        unsort(l,mid);
        unsort(mid+1,r);
    }

}

beg{

ll t,a,b,c,d,e,f,i,j,l,x,y,z,m;

//debug2(a,b);
cin >> n >> k;

fo(i,n){
    arr.pb(i+1);
}

if(k%2==0){
    cout<<-1<<endl;
    bye;
}

k--;
unsort(0,n-1);

if(k){
    cout<<-1<<endl;
    bye;
}
else{
    fo(i,arr.size()){
        cout<<arr[i]<<" ";
    }
}
ret;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(r<=l+1)
    return;

    if(k==0)
    {
        sort(a+l,a+r+1);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m-1);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n-1);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(l+1==r)
    return;

    if(k==0)
    {
        sort(a+l,a+r);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(l>=r)
    return;

    if(k==0)
    {
        sort(a+l,a+r+1);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m-1);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n-1);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(l>=r)
    return;

    if(k==0)
    {
        sort(a+l,a+r+1);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n-1);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(l>=r)
    return;

    if(k==0)
    {
        sort(a+l,a+r+1);
        return;
    }

    if(l+1==r)
    --k;
    else
    k-=2;

    in m=(l+r)/2;

    ms(a,l,m-1);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n-1);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(l+1==r)
    return;

    if(k==0)
    {
        sort(a+l,a+r);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n-1);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(l==r)
    return;

    if(k==0)
    {
        sort(a+l,a+r+1);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m-1);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n-1);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void ms(in a[],in l,in r)
{
    if(l+1==r)
    return;

    if(k==0)
    {
        sort(a+l,a+r);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m);
    ms(a,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0||k>=2*n)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


#include<bits/stdc++.h>
using namespace std;

typedef long long int in;

in k;

void merge(in a[],in l,in m,in r)
{
    in i,j,k;
    in n1=m-l+1;
    in n2=r-m;

    in L[n1],R[n2];

    for(i=0;i<n1;++i)
    L[i]=a[l+i];
    for(j=0;j<n2;++j)
    R[j]=a[m+1+j];

    i=0;
    j=0;
    k=l;
    while(i<n1&&j<n2)
    {
        if(L[i]<=R[j])
        {
            a[k]=L[i];
            ++i;
        }
        else
        {
            a[k]=R[j];
            ++j;
        }

        ++k;
    }

    while(i<n1)
    {
        a[k]=L[i];
        ++i;
        ++k;
    }

    while(j<n2)
    {
        a[k]=R[j];
        ++j;
        ++k;
    }
}

void ms(in a[],in l,in r)
{
    if(l==r)
    return;

    if(k==0)
    {
        sort(a+l,a+r+1);
        return;
    }

    k-=2;

    in m=(l+r)/2;

    ms(a,l,m-1);
    ms(a,m,r);

    merge(a,l,m,r);
}

int main()
{
    in n,i;
    cin>>n>>k;

    if(k==1)
    {
        for(i=1;i<=n;++i)
        cout<<i<<" ";

        return 0;
    }

    if(k%2==0)
    {
        cout<<"-1";
        return 0;
    }

    in a[n];

    for(i=0;i<n;++i)
    a[i]=n-i;

    --k;

    ms(a,0,n-1);

    for(i=0;i<n;++i)
    cout<<a[i]<<" ";

    return 0;
}


/*input
10000 10001
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

vector<ll> arr;
void keepcall(int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
	{
		return;
	}
	if(end-st+1==2)
	{
		//cout<<net<<endl;
		net+=2;
		keepcall(st,st,net,req,size);
		keepcall(end,end,net,req,size);
		return;
	}
	ll mid=st+(end-st)/2;
	if(mid-1>=0)
	{
		ll tmp=arr[mid];
		arr[mid]=arr[mid-1];
		arr[mid-1]=tmp;

	net+=2;
	keepcall(st,mid-1,net,req,size);
	keepcall(mid,end,net,req,size);
	}
}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	//vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(0,n-1,net,k,n);

	if(net==k)
	{
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		{
			cout<<-1;
		}
	return 0;
}


/*input
3 3
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

vector<ll> arr;
void keepcall(int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
	{
		net+=1;
		return;
	}
	if(end-st+1==2)
	{
		net+=2;
		keepcall(st,st,net,req,size);
		keepcall(end,end,net,req,size);
		return;
	}
	ll mid=st+(end-st)/2;
	if(mid-1>=0)
	{
		ll tmp=arr[mid];
		arr[mid]=arr[mid-1];
		arr[mid-1]=tmp;

	net+=2;
	keepcall(st,mid-1,net,req,size);
	keepcall(mid,end,net,req,size);
	}
}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	//vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(0,n-1,net,k,n);

	if(net==k)
	{
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		cout<<-1;
	return 0;
}


/*input
3 5
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

vector<ll> arr;
void keepcall(int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
		return;
	if(end-st+1==2)
	{
		//cout<<net<<endl;
		net+=2;
		swap(arr[st],arr[end]);
		return;
	}
	int mid=st+(end-st)/2;
	//cout<<st<<" "<<mid<<endl;

	if((end-st+1)%2==0)
	{rep(i,st,mid+1)
	{
		//if(i+mid<size)
		//cout<<arr[i]<<" "<<arr[i+mid-st+1]<<endl;
		swap(arr[i],arr[i+mid-st+1]);
	}
//	rep(i,0,size)
	//cout<<arr[i];
//	cout<<endl;
	}
	else
	{
		rep(i,st,mid)
			{
				swap(arr[i],arr[i+mid-st+1]);
			}
		ll tmp=arr[mid];
		ll prev;
		rep(i,st,mid+1)
		{
			prev=arr[i];
			arr[i]=tmp;
			tmp=prev;
		}
		//rep(i,0,size)
		//cout<<arr[i];
	}

	net+=2;
		keepcall(st,mid,net,req,size);
		keepcall(mid+1,end,net,req,size);

}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	//vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(0,n-1,net,k,n);

	if(net==k)
	{
		//cout<<net<<endl;
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		{
			cout<<-1;
		}
	return 0;
}


/*input
5 5
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

vector<ll> arr;
void keepcall(int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
		return;
	if(end-st+1==2)
	{
		//cout<<net<<endl;
		net+=2;
		swap(arr[st],arr[end]);
		return;
	}
	int mid=st+(end-st)/2;
	//cout<<st<<" "<<mid<<endl;

	if((end-st+1)%2==0)
	{rep(i,st,mid+1)
	{
		//if(i+mid<size)
		//cout<<arr[i]<<" "<<arr[i+mid-st+1]<<endl;
		swap(arr[i],arr[i+mid-st+1]);
	}
//	rep(i,0,size)
	//cout<<arr[i];
//	cout<<endl;
	}
	else
	{
		rep(i,st,mid)
			{
				swap(arr[i],arr[i+mid-st+1]);
			}

		ll tmp=arr[mid];
		ll prev;
		for(int i=end;i>=mid;i--)
		{
			prev=arr[i];
			arr[i]=tmp;
		//	cout<<arr[i]<<endl;
			tmp=prev;
		}
	//rep(i,0,size)
	//	cout<<arr[i];

	}

	net+=2;
	keepcall(st,mid-1,net,req,size);
	keepcall(mid,end,net,req,size);

}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	//vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(0,n-1,net,k,n);

	if(net==k)
	{
		//cout<<net<<endl;
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		{
			cout<<-1;
		}
	return 0;
}


/*input
3 5
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

vector<ll> arr;
void keepcall(int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
		return;
	if(end-st+1==2)
	{
		//cout<<net<<endl;
		net+=2;
		swap(arr[st],arr[end]);
		return;
	}
	int mid=st+(end-st)/2;
	//cout<<st<<" "<<mid<<endl;

	if((end-st+1)%2==0)
	{rep(i,st,mid+1)
	{
		//if(i+mid<size)
		//cout<<arr[i]<<" "<<arr[i+mid-st+1]<<endl;
		swap(arr[i],arr[i+mid-st+1]);
	}
	net+=2;
	keepcall(st,mid,net,req,size);
	keepcall(mid+1,end,net,req,size);
	}
	else
	{
		rep(i,st,mid)
			{
				swap(arr[i],arr[i+mid-st+1]);
			}

		ll tmp=arr[mid];
		ll prev;
		for(int i=end;i>=mid;i--)
		{
			prev=arr[i];
			arr[i]=tmp;
		//	cout<<arr[i]<<endl;
			tmp=prev;
		}

	net+=2;
	keepcall(st,mid-1,net,req,size);
	keepcall(mid,end,net,req,size);
	}

}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	//vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(0,n-1,net,k,n);

	if(net==k)
	{
		//cout<<net<<endl;
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		{
			cout<<-1;
		}
	return 0;
}


/*input
10000 10001
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

vector<ll> arr;
void keepcall(int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
	{
		net+=2;
		return;
	}
	if(end-st+1==2)
	{
		//cout<<net<<endl;
		net+=2;
		keepcall(st,st,net,req,size);
		keepcall(end,end,net,req,size);
		return;
	}
	ll mid=st+(end-st)/2;
	if(mid-1>=0)
	{
		ll tmp=arr[mid];
		arr[mid]=arr[mid-1];
		arr[mid-1]=tmp;

	net+=2;
	keepcall(st,mid-1,net,req,size);
	keepcall(mid,end,net,req,size);
	}
}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	//vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(0,n-1,net,k,n);

	if(net==k)
	{
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		{
			cout<<-1;
		}
	return 0;
}


/*input
10000 10001
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

vector<ll> arr;
void keepcall(int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
		return;
	if(end-st+1==2)
	{
		//cout<<net<<endl;
		net+=2;
		swap(arr[st],arr[end]);
		return;
	}
	int mid=st+(end-st)/2;
	//cout << mid << endl;
		ll tmp=arr[mid];
		arr[mid]=arr[mid-1];
		arr[mid-1]=tmp;

	net+=2;
	keepcall(st,mid-1,net,req,size);
	keepcall(mid,end,net,req,size);

}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	//vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(0,n-1,net,k,n);

	if(net==k)
	{
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		{
			cout<<-1;
		}
	return 0;
}


/*input
3 3
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

void keepcall(vector<ll> &arr,int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
	{
		net+=1;
		return;
	}
	ll mid=st+(end-st)/2;
	if(mid-1>=0)
	{
		swap(arr[mid-1],arr[mid]);
	}
	net+=2;
	keepcall(arr,st,mid-1,net,req,size);
	keepcall(arr,mid,end,net,req,size);
}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(arr,0,n-1,net,k,n);

	if(net==k)
	{
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		cout<<-1;
	return 0;
}


/*input
5 6
*/

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define ld long double
#define mp make_pair
#define F first
#define S second
#define rep(i,a,b) for(int i=a;i<b;i++)
#define per(i,b,a) for(int i=b;i>=a;i--)
using namespace std;
#define ret 100000000000000000
#define mod 1000000007

void keepcall(vector<ll> &arr,int st,int end,int & net,int req,int size)
{
	if(net==req)
		return;
	if(st==end)
	{
		net+=1;
		return;
	}
	ll mid=st+(end-st)/2;
	if(mid+1<size)
	{
		swap(arr[mid+1],arr[mid]);
	}
	net+=2;
	keepcall(arr,st,mid,net,req,size);
	keepcall(arr,mid+1,end,net,req,size);
}

int main()

{
	ll n,k;
	cin>>n>>k;

	if(k%2==0)
	{
		cout<<-1<<endl;
		return 0;
	}
	int net=1;
	vector<ll> arr;
	rep(i,0,n)
	{
		arr.pb(i+1);
	}
	keepcall(arr,0,n-1,net,k,n);

	if(net==k)
	{
		rep(i,0,n)
	cout<<arr[i]<<" ";
	}
	else
		cout<<-1;
	return 0;
}


//这题让局部有序，两个局部确实无序的，就可以了

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,k;
int dat[100000+10];
void merge(int l,int r)
{
    if(k==0)
        return;
    if(r==l)return;
    k-=2;
    vector<int> tmp;
    int mid = (r+l)>>1;
    // for (int i = (r-l+1)/2+1; i < r-l+1; i++)
    // {
    //     tmp.push_back(dat[l+i]);
    // }
    // for (int i = 0;i<=(r-l+1)/2;i++)
    // {
    //     tmp.push_back(dat[l+i]);// 这里错了，要从上面的循环的位置开始才行
    // }
    int cut = 0;
    if((r-l+1)%2) cut=1;
    for (int i = mid+1; i <=r-cut; i++) //解决方法是只转换前偶数个数 所以减去tmp.size()%2;
    {
        tmp.push_back(dat[i]);
    }

    for (int i = l; i <= mid; i++)
    {
        tmp.push_back(dat[i]);
    }
    for (int i = 0; i < tmp.size(); i++)
    {
        dat[i+l] = tmp[i];
    }
    merge(l,mid);//这时错的，当把后面的数调到前面时，数量可能会不一样的。//解决方法是只转换前偶数个数
    merge(mid+1,r);
}

int main()
{
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\output.txt","w",stdout);//
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\input.txt","r",stdin);//

    ios::sync_with_stdio(false);

    cin>>n>>k;
    for (int i = 0; i < 100000+10; i++)
    {
        dat[i] = i+1;
    }
    k--;
    if(k&1)
    {
        return cout<<-1<<endl,0;
    }
    merge(0,n-1);
    if(k==0)
    {
        for (int i = 0; i < n; i++)
        {
            cout<<dat[i]<<" ";
        }
        cout<<endl;
    }else{
        cout<<-1<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;
int remain=0;
int merge(int l,int r)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
    for(int i=l;i<mid;i++)
    {
        swap(vec[i],vec[mid+(i-l)]);
    }
    remain-=2;
    merge(l,mid);
    merge(mid,r);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    remain=k-1;
    merge(0,n);

    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}


//这题让局部有序，两个局部确实无序的，就可以了

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,k;
int dat[100000+10];
void merge(int l,int r)
{
    if(k==0)
        return;
    if(r==l)return;
    k-=2;
    vector<int> tmp;
    int mid = (r+l)>>1;
    // for (int i = (r-l+1)/2+1; i < r-l+1; i++)
    // {
    //     tmp.push_back(dat[l+i]);
    // }
    // for (int i = 0;i<=(r-l+1)/2;i++)
    // {
    //     tmp.push_back(dat[l+i]);// 这里错了，要从上面的循环的位置开始才行
    // }
    for (int i = l; i <= mid; i++)
    {
        tmp.push_back(dat[i]);
    }
    for (int i = mid+1; i <=r; i++)
    {
        tmp.push_back(dat[i]);
    }

    for (int i = 0; i < tmp.size(); i++)
    {
        dat[i+l] = tmp[i];
    }
    merge(l,mid);
    merge(mid+1,r);
}

int main()
{
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\output.txt","w",stdout);//
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\input.txt","r",stdin);//

    ios::sync_with_stdio(false);

    cin>>n>>k;
    for (int i = 0; i < 100000+10; i++)
    {
        dat[i] = i+1;
    }
    k--;
    if(k&1)
    {
        return cout<<-1<<endl,0;
    }
    merge(0,n-1);
    if(k==0)
    {
        for (int i = 0; i < n; i++)
        {
            cout<<dat[i]<<" ";
        }
        cout<<endl;
    }else{
        cout<<-1<<endl;
    }

    return 0;
}


//这题让局部有序，两个局部确实无序的，就可以了

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,k;
int dat[100000+10];
void merge(int l,int r)
{
    if(k==0)
        return;
    if(r==l)return;
    k-=2;
    vector<int> tmp;
    int mid = (r+l)>>1;
    // for (int i = (r-l+1)/2+1; i < r-l+1; i++)
    // {
    //     tmp.push_back(dat[l+i]);
    // }
    // for (int i = 0;i<=(r-l+1)/2;i++)
    // {
    //     tmp.push_back(dat[l+i]);// 这里错了，要从上面的循环的位置开始才行
    // }
    for (int i = mid+1; i <=r; i++)
    {
        tmp.push_back(dat[i]);
    }

    for (int i = l; i <= mid; i++)
    {
        tmp.push_back(dat[i]);
    }
    for (int i = tmp.size()%2; i < tmp.size(); i++) //解决方法是只转换前偶数个数 所以减去tmp.size()%2;
    {
        dat[i+l] = tmp[i];
    }
    merge(l,mid);//这时错的，当把后面的数调到前面时，数量可能会不一样的。//解决方法是只转换前偶数个数
    merge(mid+1,r);
}

int main()
{
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\output.txt","w",stdout);//
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\input.txt","r",stdin);//

    ios::sync_with_stdio(false);

    cin>>n>>k;
    for (int i = 0; i < 100000+10; i++)
    {
        dat[i] = i+1;
    }
    k--;
    if(k&1)
    {
        return cout<<-1<<endl,0;
    }
    merge(0,n-1);
    if(k==0)
    {
        for (int i = 0; i < n; i++)
        {
            cout<<dat[i]<<" ";
        }
        cout<<endl;
    }else{
        cout<<-1<<endl;
    }

    return 0;
}


//这题让局部有序，两个局部确实无序的，就可以了

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,k;
int dat[100000+10];
void merge(int l,int r)
{
    if(k==0)
        return;
    if(r==l)return;
    k-=2;
    vector<int> tmp;
    int mid = (r+l)>>1;
    // for (int i = (r-l+1)/2+1; i < r-l+1; i++)
    // {
    //     tmp.push_back(dat[l+i]);
    // }
    // for (int i = 0;i<=(r-l+1)/2;i++)
    // {
    //     tmp.push_back(dat[l+i]);// 这里错了，要从上面的循环的位置开始才行
    // }
    for (int i = mid+1; i <=r; i++)
    {
        tmp.push_back(dat[i]);
    }

    for (int i = l; i <= mid; i++)
    {
        tmp.push_back(dat[i]);
    }
    for (int i = 0; i < tmp.size(); i++)
    {
        dat[i+l] = tmp[i];
    }
    merge(l,mid);
    merge(mid+1,r);
}

int main()
{
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\output.txt","w",stdout);//
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\input.txt","r",stdin);//

    ios::sync_with_stdio(false);

    cin>>n>>k;
    for (int i = 0; i < 100000+10; i++)
    {
        dat[i] = i+1;
    }
    k--;
    if(k&1)
    {
        return cout<<-1<<endl,0;
    }
    merge(0,n-1);
    if(k==0)
    {
        for (int i = 0; i < n; i++)
        {
            cout<<dat[i]<<" ";
        }
        cout<<endl;
    }else{
        cout<<-1<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;

int merge(int l,int r,int remain)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
    for(int i=l;i<mid;i++)
    {
        swap(vec[i],vec[mid+(i-l)]);
    }
    merge(l,mid,remain-2)
    merge(mid,r,remain-2);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    merge(0,n,k-1);
    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;
int remain=0;
int merge(int l,int r)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
    if(mid==l)
        return 0;
    for(int i=l;i<mid;i++)
    {
        swap(vec[i],vec[mid+(i-l)]);
    }
//    swap(vec[mid-1],vec[mid]);

    remain-=2;
    merge(l,mid);
    merge(mid,r);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    remain=k-1;
    merge(0,n);

    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}


//这题让局部有序，两个局部确实无序的，就可以了
//这题有一点要注意的是，偶数分为两堆和奇数分为两堆是不同的，要注意这点
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,k;
int dat[100000+10];
void merge(int l,int r)
{
    if(k==0)
        return;
    if(r==l)return;
    k-=2;
    vector<int> tmp;
    int mid = (r+l)>>1;
    // for (int i = (r-l+1)/2+1; i < r-l+1; i++)
    // {
    //     tmp.push_back(dat[l+i]);
    // }
    // for (int i = 0;i<=(r-l+1)/2;i++)
    // {
    //     tmp.push_back(dat[l+i]);// 这里错了，要从上面的循环的位置开始才行
    // }
    int cut = 0;
    if((r-l+1)%2) cut=1;
    for (int i = mid+1-cut; i <=r; i++) //解决方法是只转换前偶数个数 所以减去tmp.size()%2;
    {
        tmp.push_back(dat[i]);
    }

    for (int i = l; i <= mid-cut; i++)
    {
        tmp.push_back(dat[i]);
    }
    for (int i = 0; i < tmp.size(); i++)
    {
        dat[i+l] = tmp[i];
    }
    merge(l,mid);//这时错的，当把后面的数调到前面时，数量可能会不一样的。//解决方法是只转换前偶数个数
    merge(mid+1,r);
}

int main()
{
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\output.txt","w",stdout);//
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\input.txt","r",stdin);//

    ios::sync_with_stdio(false);

    cin>>n>>k;
    for (int i = 0; i < 100000+10; i++)
    {
        dat[i] = i+1;
    }
    k--;
    if(k&1)
    {
        return cout<<-1<<endl,0;
    }
    merge(0,n-1);
    if(k==0)
    {
        for (int i = 0; i < n; i++)
        {
            cout<<dat[i]<<" ";
        }
        cout<<endl;
    }else{
        cout<<-1<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;
int remain=0;
int merge(int l,int r)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
    if(mid==l)
        return 0;
    swap(vec[mid-1],vec[mid]);

    remain-=2;
    merge(l,mid);
    merge(mid,r);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    remain=k-1;
    merge(0,n);

    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;

int merge(int l,int r,int remain)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
    for(int i=l;i<mid;i++)
    {
        swap(vec[i],vec[mid+(i-l)]);
    }
    merge(l,mid,remain-2);
    merge(mid,r,remain-2);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    merge(0,n,k-1);
    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}


//这题让局部有序，两个局部确实无序的，就可以了

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int n,k;
int dat[100000+10];
void merge(int l,int r)
{
    if(k==0)
        return;
    if(r==l)return;
    k-=2;
    vector<int> tmp;
    int mid = (r+l)>>1;
    // for (int i = (r-l+1)/2+1; i < r-l+1; i++)
    // {
    //     tmp.push_back(dat[l+i]);
    // }
    // for (int i = 0;i<=(r-l+1)/2;i++)
    // {
    //     tmp.push_back(dat[l+i]);// 这里错了，要从上面的循环的位置开始才行
    // }
    for (int i = mid+1; i <=r; i++)
    {
        tmp.push_back(dat[i]);
    }

    for (int i = l; i <= mid; i++)
    {
        tmp.push_back(dat[i]);
    }
    for (int i = 0; i < tmp.size()-tmp.size()%2; i++) //解决方法是转换前偶数个数 所以减去tmp.size()%2;
    {
        dat[i+l] = tmp[i];
    }
    merge(l,mid);//这时错的，当把后面的数调到前面时，数量可能会不一样的。//解决方法是转换前偶数个数
    merge(mid+1,r);
}

int main()
{
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\output.txt","w",stdout);//
    //freopen("C:\\Users\\37\\Documents\\project\\atom\\Algorithm\\Algorithm\\input.txt","r",stdin);//

    ios::sync_with_stdio(false);

    cin>>n>>k;
    for (int i = 0; i < 100000+10; i++)
    {
        dat[i] = i+1;
    }
    k--;
    if(k&1)
    {
        return cout<<-1<<endl,0;
    }
    merge(0,n-1);
    if(k==0)
    {
        for (int i = 0; i < n; i++)
        {
            cout<<dat[i]<<" ";
        }
        cout<<endl;
    }else{
        cout<<-1<<endl;
    }

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;

int merge(int l,int r,int remain)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
//    for(int i=l;i<mid;i++)
//    {
//        swap(vec[i],vec[mid+(i-l)]);
 //   }
    swap(vec[mid-1],vec[mid]);
    merge(l,mid,remain-2);
    merge(mid,r,remain-2);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    merge(0,n,k-1);
    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;
int remain=0;
int merge(int l,int r)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
    if(mid==l)
        return 0;
    swap(mid-1,mid);

    remain-=2;
    merge(l,mid);
    merge(mid,r);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    remain=k-1;
    merge(0,n);

    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

vector<int> vec;
int remain=0;
int merge(int l,int r)
{
    if(remain==0)
    {
        return 0;
    }
    int mid = (l+r)/2;
//    if(mid==l)//这个判断好像是必要的
//        return 0;
    for(int i=l;i<mid;i++)
    {
        swap(vec[i],vec[mid+(i-l)]);
    }
//    swap(vec[mid-1],vec[mid]);

    remain-=2;
    merge(l,mid);
    merge(mid,r);
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin>>n>>k;
    if((k&1)==0)
    {
        cout<<-1<<endl;
        return 0;
    }
    if(k>=2*n)
    {
        cout<<-1<<endl;
        return 0;
    }
    for(int i=1;i<=n;i++)
    {
        vec.push_back(i);
    }
    remain=k-1;
    merge(0,n);

    for(auto a:vec)
    {
        cout<<a<<" ";
    }
    cout<<endl;

    return 0;
}