import java.io.*;

class HashPaare {
    int n; // n Zahlen mit verschiedenen paarweisen Summen
    int a, b;
    int[] lösung;
    boolean[] besetzt;

    class LösungGefunden extends Exception {}

    void positioniere(int k) throws LösungGefunden {
        // Die ersten k Zahlen sind bereits gewählt.
	int l;
	if (k==n)
	    throw new LösungGefunden(); // falls nur eine Lösung gesucht ist
	    // druckeLösung(); // falls alle Lösungen gesucht sind
	for (int p=lösung[k-1]+1; p<=b-lösung[k-1]; p++)
	    // man könnte die obere Schranke "p<=b-l[k-1]" noch verschärfen
	    if (!konflikt(k,p)) {
		    lösung[k] = p;
		    for (l=0; l<k; l++) besetzt[lösung[l]+p-a] = true;
		    positioniere(k+1);
		    for (l=0; l<k; l++) besetzt[lösung[l]+p-a] = false;
		}
    }

    boolean konflikt(int k, int pos) {
	// teste "lösung[k]=pos"
	for (int l=0; l<k; l++)
	    if (besetzt[lösung[l]+pos-a])
		   return true;
	return false;
    }

    HashPaare(int AnzahlZahlen, int aa, int bb) {
	n = AnzahlZahlen;
	a = aa;
	b = bb;
	// Suche eine Lösung l[0]<l[1]<...<l[n-1]
	// mit kleinster Summe l[0]+l[1]=a
	// und größter Summe l[n-2]+l[n-1]<=b

	lösung = new int[n];
	besetzt = new boolean [b+1-a];
	for (int i=a; i<=b; i++) besetzt [i-a]=false;
	try {
	    for (int mini = (a-1)/2; mini>=a-b; mini--) {
		lösung[0] = mini;
		lösung[1] = a-mini;
		// Die beiden ersten Werte werden in dieser Schleife
		// speziell gesetzt.
		besetzt[0]=true;
		positioniere(2); // ab dem dritten Wert gewöhnliches Backtracking
		besetzt[0]=false;
	    }
	    System.out.println("Keine Lösung");
	}
	catch(LösungGefunden e) {
	    druckeLösung();
	    // for (int i=a; i<=b; i++) System.out.print(i+":"+ besetzt [i-a]+" ");
	    // System.out.println();
	}
    }

    void druckeLösung() {
	for (int i=0; i<n; i++) System.out.print(lösung[i]+", ");
	System.out.println();
    }

    public static void main(String [] args)
    {
	int l = Integer.parseInt(args[1]);
	// Eingabe: n und Länge l des gesuchten Intervalls {a,...,b}
	// Das kleinste l muss man mit diesem Programm
	// durch Probieren "von Hand" suchen.

	// Durch Addition einer Konstanten zu allen Zahlen kann
	// man ohne Beschränkung der Allgemeinheit annehmen, dass
	// die kleinste Summe (l[0]+l[1]=a) a=1 oder a=2 ist.
	new HashPaare(Integer.parseInt(args[0]),1,l);
	new HashPaare(Integer.parseInt(args[0]),2,l+1);
    }
}