description: Let's call a set of positive integers a_1, a_2, ..., a_k quadratic if the product of the factorials of its elements is a square of an integer, i. e. ∏_{i=1}^{k} a_i! = m^2, for some integer m.
  
  You are given a positive integer n.
  
  Your task is to find a quadratic subset of a set 1, 2, ..., n of maximum size. If there are multiple answers, print any of them.
  
  Input
  
  A single line contains a single integer n (1 ≤ n ≤ 10^6).
  
  Output
  
  In the first line, print a single integer — the size of the maximum subset. In the second line, print the subset itself in an arbitrary order.
  
  Examples
  
  Input
  
  
  1
  
  
  Output
  
  
  1
  1 
  
  
  Input
  
  
  4
  
  
  Output
  
  
  3
  1 3 4 
  
  
  Input
  
  
  7
  
  
  Output
  
  
  4
  1 4 5 6 
  
  
  Input
  
  
  9
  
  
  Output
  
  
  7
  1 2 4 5 6 7 9 
solution: //package ecr120;
  import java.io.*;
  import java.util.*;
  
  public class F2 {
  	InputStream is;
  	FastWriter out;
  	String INPUT = "";
  
  	void print(int n, int... rem)
  	{
  		Set<Integer> re = new HashSet<>();
  		for(int v : rem)re.add(v);
  		out.println(n - rem.length);
  		for(int i = 1;i <= n;i++){
  			if(!re.contains(i)){
  				out.print(i + " ");
  			}
  		}
  		out.println();
  	}
  	
  	void solve()
  	{
  		int n = ni();
  		if(n == 1){
  			print(1);
  			return;
  		}
  		if(n % 4 == 0){
  			print(n, n/2);
  			return;
  		}
  
  		int[] primes = sieveEratosthenes(1000000);
  		Random gen = new Random(114514);
  		long[] zob = new long[1000000 + 1];
  		for (int i = 0; i <= 1000000; i++) zob[i] = gen.nextLong();
  
  		int[] lpf = enumLowestPrimeFactors(1000000);
  		long[] cum = new long[1000000 + 1];
  		for (int i = 1; i <= 1000000; i++) {
  			int[][] f = factorFast(i, lpf);
  			cum[i] = cum[i - 1];
  			for (int[] p : f) {
  				if (p[1] % 2 == 1) {
  					cum[i] ^= zob[p[0]];
  				}
  			}
  		}
  
  		boolean[] hit = new boolean[n + 1];
  		for (int p : primes) {
  			// (n/p)(n/p+1)/2 * p
  			long num = 0;
  			for (long q = p; q <= n; q *= p) {
  				num += (n / q) * (n / q - 1) / 2 * q + n / q * (n % q + 1);
  			}
  			if (num % 2 == 1) {
  				hit[p] = true;
  			}
  		}
  
  		long ex = 0;
  		for (int i = 0; i <= n; i++) {
  			if (hit[i]) ex ^= zob[i];
  		}
  
  		for (int i = 0; i <= n; i++) {
  			if(cum[i] == ex){
  				print(n, i);
  				return;
  			}
  		}
  
  		if(n % 4 == 2){
  			print(n, 2, n/2);
  			return;
  		}
  		if(n % 4 == 1){
  			print(n, n, n/2);
  			return;
  		}
  
  		Map<Long, Integer> map = new HashMap<>();
  		for(int i = 1;i <= n;i++){
  			map.put(cum[i] ^ ex, i);
  		}
  
  		for (int i = 1; i <= n; i++) {
  			if(map.containsKey(cum[i])){
  				print(n, map.get(cum[i]), i);
  				return;
  			}
  		}
  		print(n, n/2, 2, n);
  	}
  
  	public static int[][] factorFast(int n, int[] lpf)
  	{
  		int[][] f = new int[9][];
  		int q = 0;
  		while(lpf[n] > 0){
  			int p = lpf[n];
  			if(q == 0 || p != f[q-1][0]){
  				f[q++] = new int[]{p, 1};
  			}else{
  				f[q-1][1]++;
  			}
  			n /= p;
  		}
  		return Arrays.copyOf(f, q);
  	}
  
  
  	public static int[] enumLowestPrimeFactors(int n)
  	{
  		int tot = 0;
  		int[] lpf = new int[n+1];
  		int u = n+32;
  		double lu = Math.log(u);
  		int[] primes = new int[(int)(u/lu+u/lu/lu*1.5)];
  		for(int i = 2;i <= n;i++)lpf[i] = i;
  		for(int p = 2;p <= n;p++){
  			if(lpf[p] == p)primes[tot++] = p;
  			int tmp;
  			for(int i = 0;i < tot && primes[i] <= lpf[p] && (tmp = primes[i]*p) <= n;i++){
  				lpf[tmp] = primes[i];
  			}
  		}
  		return lpf;
  	}
  
  
  	public static int[] sieveEratosthenes(int n) {
  		if (n <= 32) {
  			int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
  			for (int i = 0; i < primes.length; i++) {
  				if (n < primes[i]) {
  					return Arrays.copyOf(primes, i);
  				}
  			}
  			return primes;
  		}
  
  		int u = n + 32;
  		double lu = Math.log(u);
  		int[] ret = new int[(int) (u / lu + u / lu / lu * 1.5)];
  		ret[0] = 2;
  		int pos = 1;
  
  		int[] isnp = new int[(n + 1) / 32 / 2 + 1];
  		int sup = (n + 1) / 32 / 2 + 1;
  
  		int[] tprimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
  		for (int tp : tprimes) {
  			ret[pos++] = tp;
  			int[] ptn = new int[tp];
  			for (int i = (tp - 3) / 2; i < tp << 5; i += tp) ptn[i >> 5] |= 1 << (i & 31);
  			for (int j = 0; j < sup; j += tp) {
  				for (int i = 0; i < tp && i + j < sup; i++) {
  					isnp[j + i] |= ptn[i];
  				}
  			}
  		}
  
  		// 3,5,7
  		// 2x+3=n
  		int[] magic = {0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13, 31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14};
  		int h = n / 2;
  		for (int i = 0; i < sup; i++) {
  			for (int j = ~isnp[i]; j != 0; j &= j - 1) {
  				int pp = i << 5 | magic[(j & -j) * 0x076be629 >>> 27];
  				int p = 2 * pp + 3;
  				if (p > n) break;
  				ret[pos++] = p;
  				if ((long) p * p > n) continue;
  				for (int q = (p * p - 3) / 2; q <= h; q += p) isnp[q >> 5] |= 1 << q;
  			}
  		}
  
  		return Arrays.copyOf(ret, pos);
  	}
  
  
  	void run() throws Exception
  	{
  		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
  		out = new FastWriter(System.out);
  		
  		long s = System.currentTimeMillis();
  		solve();
  		out.flush();
  		tr(System.currentTimeMillis()-s+"ms");
  	}
  	
  	public static void main(String[] args) throws Exception { new F2().run(); }
  	
  	private byte[] inbuf = new byte[1024];
  	public int lenbuf = 0, ptrbuf = 0;
  	
  	private int readByte()
  	{
  		if(lenbuf == -1)throw new InputMismatchException();
  		if(ptrbuf >= lenbuf){
  			ptrbuf = 0;
  			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
  			if(lenbuf <= 0)return -1;
  		}
  		return inbuf[ptrbuf++];
  	}
  	
  	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
  	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
  	
  	private double nd() { return Double.parseDouble(ns()); }
  	private char nc() { return (char)skip(); }
  	
  	private String ns()
  	{
  		int b = skip();
  		StringBuilder sb = new StringBuilder();
  		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
  			sb.appendCodePoint(b);
  			b = readByte();
  		}
  		return sb.toString();
  	}
  	
  	private char[] ns(int n)
  	{
  		char[] buf = new char[n];
  		int b = skip(), p = 0;
  		while(p < n && !(isSpaceChar(b))){
  			buf[p++] = (char)b;
  			b = readByte();
  		}
  		return n == p ? buf : Arrays.copyOf(buf, p);
  	}
  
  	private int[] na(int n)
  	{
  		int[] a = new int[n];
  		for(int i = 0;i < n;i++)a[i] = ni();
  		return a;
  	}
  
  	private long[] nal(int n)
  	{
  		long[] a = new long[n];
  		for(int i = 0;i < n;i++)a[i] = nl();
  		return a;
  	}
  
  	private char[][] nm(int n, int m) {
  		char[][] map = new char[n][];
  		for(int i = 0;i < n;i++)map[i] = ns(m);
  		return map;
  	}
  
  	private int[][] nmi(int n, int m) {
  		int[][] map = new int[n][];
  		for(int i = 0;i < n;i++)map[i] = na(m);
  		return map;
  	}
  
  	private int ni() { return (int)nl(); }
  
  	private long nl()
  	{
  		long num = 0;
  		int b;
  		boolean minus = false;
  		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
  		if(b == '-'){
  			minus = true;
  			b = readByte();
  		}
  
  		while(true){
  			if(b >= '0' && b <= '9'){
  				num = num * 10 + (b - '0');
  			}else{
  				return minus ? -num : num;
  			}
  			b = readByte();
  		}
  	}
  
  	public static class FastWriter
  	{
  		private static final int BUF_SIZE = 1<<13;
  		private final byte[] buf = new byte[BUF_SIZE];
  		private final OutputStream out;
  		private int ptr = 0;
  
  		private FastWriter(){out = null;}
  
  		public FastWriter(OutputStream os)
  		{
  			this.out = os;
  		}
  
  		public FastWriter(String path)
  		{
  			try {
  				this.out = new FileOutputStream(path);
  			} catch (FileNotFoundException e) {
  				throw new RuntimeException("FastWriter");
  			}
  		}
  
  		public FastWriter write(byte b)
  		{
  			buf[ptr++] = b;
  			if(ptr == BUF_SIZE)innerflush();
  			return this;
  		}
  
  		public FastWriter write(char c)
  		{
  			return write((byte)c);
  		}
  
  		public FastWriter write(char[] s)
  		{
  			for(char c : s){
  				buf[ptr++] = (byte)c;
  				if(ptr == BUF_SIZE)innerflush();
  			}
  			return this;
  		}
  
  		public FastWriter write(String s)
  		{
  			s.chars().forEach(c -> {
  				buf[ptr++] = (byte)c;
  				if(ptr == BUF_SIZE)innerflush();
  			});
  			return this;
  		}
  
  		private static int countDigits(int l) {
  			if (l >= 1000000000) return 10;
  			if (l >= 100000000) return 9;
  			if (l >= 10000000) return 8;
  			if (l >= 1000000) return 7;
  			if (l >= 100000) return 6;
  			if (l >= 10000) return 5;
  			if (l >= 1000) return 4;
  			if (l >= 100) return 3;
  			if (l >= 10) return 2;
  			return 1;
  		}
  
  		public FastWriter write(int x)
  		{
  			if(x == Integer.MIN_VALUE){
  				return write((long)x);
  			}
  			if(ptr + 12 >= BUF_SIZE)innerflush();
  			if(x < 0){
  				write((byte)'-');
  				x = -x;
  			}
  			int d = countDigits(x);
  			for(int i = ptr + d - 1;i >= ptr;i--){
  				buf[i] = (byte)('0'+x%10);
  				x /= 10;
  			}
  			ptr += d;
  			return this;
  		}
  
  		private static int countDigits(long l) {
  			if (l >= 1000000000000000000L) return 19;
  			if (l >= 100000000000000000L) return 18;
  			if (l >= 10000000000000000L) return 17;
  			if (l >= 1000000000000000L) return 16;
  			if (l >= 100000000000000L) return 15;
  			if (l >= 10000000000000L) return 14;
  			if (l >= 1000000000000L) return 13;
  			if (l >= 100000000000L) return 12;
  			if (l >= 10000000000L) return 11;
  			if (l >= 1000000000L) return 10;
  			if (l >= 100000000L) return 9;
  			if (l >= 10000000L) return 8;
  			if (l >= 1000000L) return 7;
  			if (l >= 100000L) return 6;
  			if (l >= 10000L) return 5;
  			if (l >= 1000L) return 4;
  			if (l >= 100L) return 3;
  			if (l >= 10L) return 2;
  			return 1;
  		}
  
  		public FastWriter write(long x)
  		{
  			if(x == Long.MIN_VALUE){
  				return write("" + x);
  			}
  			if(ptr + 21 >= BUF_SIZE)innerflush();
  			if(x < 0){
  				write((byte)'-');
  				x = -x;
  			}
  			int d = countDigits(x);
  			for(int i = ptr + d - 1;i >= ptr;i--){
  				buf[i] = (byte)('0'+x%10);
  				x /= 10;
  			}
  			ptr += d;
  			return this;
  		}
  
  		public FastWriter write(double x, int precision)
  		{
  			if(x < 0){
  				write('-');
  				x = -x;
  			}
  			x += Math.pow(10, -precision)/2;
  			//		if(x < 0){ x = 0; }
  			write((long)x).write(".");
  			x -= (long)x;
  			for(int i = 0;i < precision;i++){
  				x *= 10;
  				write((char)('0'+(int)x));
  				x -= (int)x;
  			}
  			return this;
  		}
  
  		public FastWriter writeln(char c){
  			return write(c).writeln();
  		}
  
  		public FastWriter writeln(int x){
  			return write(x).writeln();
  		}
  
  		public FastWriter writeln(long x){
  			return write(x).writeln();
  		}
  
  		public FastWriter writeln(double x, int precision){
  			return write(x, precision).writeln();
  		}
  
  		public FastWriter write(int... xs)
  		{
  			boolean first = true;
  			for(int x : xs) {
  				if (!first) write(' ');
  				first = false;
  				write(x);
  			}
  			return this;
  		}
  
  		public FastWriter write(long... xs)
  		{
  			boolean first = true;
  			for(long x : xs) {
  				if (!first) write(' ');
  				first = false;
  				write(x);
  			}
  			return this;
  		}
  
  		public FastWriter writeln()
  		{
  			return write((byte)'\n');
  		}
  
  		public FastWriter writeln(int... xs)
  		{
  			return write(xs).writeln();
  		}
  
  		public FastWriter writeln(long... xs)
  		{
  			return write(xs).writeln();
  		}
  
  		public FastWriter writeln(char[] line)
  		{
  			return write(line).writeln();
  		}
  
  		public FastWriter writeln(char[]... map)
  		{
  			for(char[] line : map)write(line).writeln();
  			return this;
  		}
  
  		public FastWriter writeln(String s)
  		{
  			return write(s).writeln();
  		}
  
  		private void innerflush()
  		{
  			try {
  				out.write(buf, 0, ptr);
  				ptr = 0;
  			} catch (IOException e) {
  				throw new RuntimeException("innerflush");
  			}
  		}
  
  		public void flush()
  		{
  			innerflush();
  			try {
  				out.flush();
  			} catch (IOException e) {
  				throw new RuntimeException("flush");
  			}
  		}
  
  		public FastWriter print(byte b) { return write(b); }
  		public FastWriter print(char c) { return write(c); }
  		public FastWriter print(char[] s) { return write(s); }
  		public FastWriter print(String s) { return write(s); }
  		public FastWriter print(int x) { return write(x); }
  		public FastWriter print(long x) { return write(x); }
  		public FastWriter print(double x, int precision) { return write(x, precision); }
  		public FastWriter println(char c){ return writeln(c); }
  		public FastWriter println(int x){ return writeln(x); }
  		public FastWriter println(long x){ return writeln(x); }
  		public FastWriter println(double x, int precision){ return writeln(x, precision); }
  		public FastWriter print(int... xs) { return write(xs); }
  		public FastWriter print(long... xs) { return write(xs); }
  		public FastWriter println(int... xs) { return writeln(xs); }
  		public FastWriter println(long... xs) { return writeln(xs); }
  		public FastWriter println(char[] line) { return writeln(line); }
  		public FastWriter println(char[]... map) { return writeln(map); }
  		public FastWriter println(String s) { return writeln(s); }
  		public FastWriter println() { return writeln(); }
  	}
  
  	public void trnz(int... o)
  	{
  		for(int i = 0;i < o.length;i++)if(o[i] != 0)System.out.print(i+":"+o[i]+" ");
  		System.out.println();
  	}
  
  	// print ids which are 1
  	public void trt(long... o)
  	{
  		Queue<Integer> stands = new ArrayDeque<>();
  		for(int i = 0;i < o.length;i++){
  			for(long x = o[i];x != 0;x &= x-1)stands.add(i<<6|Long.numberOfTrailingZeros(x));
  		}
  		System.out.println(stands);
  	}
  
  	public void tf(boolean... r)
  	{
  		for(boolean x : r)System.out.print(x?'#':'.');
  		System.out.println();
  	}
  
  	public void tf(boolean[]... b)
  	{
  		for(boolean[] r : b) {
  			for(boolean x : r)System.out.print(x?'#':'.');
  			System.out.println();
  		}
  		System.out.println();
  	}
  
  	public void tf(long[]... b)
  	{
  		if(INPUT.length() != 0) {
  			for (long[] r : b) {
  				for (long x : r) {
  					for (int i = 0; i < 64; i++) {
  						System.out.print(x << ~i < 0 ? '#' : '.');
  					}
  				}
  				System.out.println();
  			}
  			System.out.println();
  		}
  	}
  
  	public void tf(long... b)
  	{
  		if(INPUT.length() != 0) {
  			for (long x : b) {
  				for (int i = 0; i < 64; i++) {
  					System.out.print(x << ~i < 0 ? '#' : '.');
  				}
  			}
  			System.out.println();
  		}
  	}
  
  	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
  	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
  }
  