A new Berland businessman Vitaly is going to open a household appliances' store. All he's got to do now is to hire the staff.

The store will work seven days a week, but not around the clock. Every day at least k people must work in the store.

Berland has a law that determines the order of working days and non-working days. Namely, each employee must work for exactly n consecutive days, then rest for exactly m days, then work for n more days and rest for m more, and so on. Vitaly doesn't want to break the law. Fortunately, there is a loophole: the law comes into force on the day when the employee is hired. For example, if an employee is hired on day x, then he should work on days [x, x + 1, ..., x + n - 1], [x + m + n, x + m + n + 1, ..., x + m + 2n - 1], and so on. Day x can be chosen arbitrarily by Vitaly.

There is one more thing: the key to the store. Berland law prohibits making copies of keys, so there is only one key. Vitaly is planning to entrust the key to the store employees. At the same time on each day the key must be with an employee who works that day — otherwise on this day no one can get inside the store. During the day the key holder can give the key to another employee, if he also works that day. The key will handed to the first hired employee at his first working day.

Each employee has to be paid salary. Therefore, Vitaly wants to hire as few employees as possible provided that the store can operate normally on each day from 1 to infinity. In other words, on each day with index from 1 to infinity, the store must have at least k working employees, and one of the working employees should have the key to the store.

Help Vitaly and determine the minimum required number of employees, as well as days on which they should be hired.

Input

The first line contains three integers n, m and k (1 ≤ m ≤ n ≤ 1000, n ≠ 1, 1 ≤ k ≤ 1000).

Output

In the first line print a single integer z — the minimum required number of employees.

In the second line print z positive integers, separated by spaces: the i-th integer ai (1 ≤ ai ≤ 104) should represent the number of the day, on which Vitaly should hire the i-th employee.

If there are multiple answers, print any of them.

Examples

Input

4 3 2


Output

4
1 1 4 5

Input

3 3 1


Output

3
1 3 5



import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;


public class Q2 {
	static FasterScanner sc;
	static int cnt=0;
	static boolean b[];
	static int[] arr,parent,color;
	static ArrayList<Integer>[] amp;
	static StringBuilder s2;
	static HashSet<Integer> hs;
	static int MOD = 1000000007;
	public static void main(String args[] ) throws Exception {
        sc=  new FasterScanner();
        BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
        int n = sc.nextInt(), m = sc.nextInt(), k =sc.nextInt();
        int cnt = 0;
        ArrayList<Integer> arr = new ArrayList<>(); 
        if(k==1){
        	if(n==m && n==2){
        		System.out.println("4");
        		System.out.print("1 2 3 4");
        	}
        	else{
        	if(!(m<n-1))
        	System.out.println("3");
        	else System.out.println("2");
        	System.out.print("1 ");
        	System.out.print(n+" ");
        	if(!(m<n-1)) System.out.print(2*n-1);
        	}
        }
        else if(n==m){
        	System.out.println(2*k+1);
        	for(int i = 0;i<k;i++) System.out.print(1+" ");
        	System.out.print(n+" ");
        	for(int i = 0;i<k-1;i++) System.out.print(n+1+" ");
        	System.out.print(2*n);
        }
        else{
        	System.out.println(2*k);
        	for(int i = 0;i<k;i++) System.out.print(1+" ");
        	System.out.print(n+" ");
        	for(int i = 0;i<k-1;i++) System.out.print(n+1+" ");
        }
        log.close(); 
   }
	public static boolean bipartite(int x){
		b[x] = true;
		for(int i =0;i<amp[x].size();i++){
			int c = amp[x].get(i);
			if(b[c]){
				if(color[c] == color[x]) return false;
			}
			else{
				color[c] = -color[x];
				bipartite(c);
			}
		}
		return true;
	}
	public static int getParent(int x){
		if(parent[x] != x) 
		parent[x] = getParent(parent[x]);
		return parent[x];
	}
	 static class Pair implements Comparable<Pair> {
			int u;
			int v;
			double dist=0;
			public Pair(){
				
			}
			public Pair(int u, int v) {
				this.u = u;
				this.v = v;
			}
			
			public int hashCode() {
				int hu = (int) (u ^ (u >>> 32));
				int hv = (int) (v ^ (v >>> 32));
				return 31*hu + hv;
			}

			public boolean equals(Object o) {
				Pair other = (Pair) o;
				return (u == other.u && v == other.v);
			}

			public int compareTo(Pair other) {
				return Long.compare(u, other.u) != 0 ? (~Long.compare(u, other.u)) : Long.compare(v,  other.v);
			}

			public String toString() {
				return "[u=" + u + ", v=" + v + "]";
			}
		}
	static class SegmentTree{
		int size;
		int amp[];
		public void size(int n){
			int x = (int)Math.ceil(Math.log(n)/Math.log(2));
			size = 2*(int)Math.pow(2, x)-1;
			amp = new int[size];
			Arrays.fill(amp,-1);
		}
		public int build(int arr[],int ss,int se,int si){
			if(ss==se) {
				amp[si] = arr[ss];
				return arr[ss];
			}
			int mid = (ss+se)/2;
			amp[si] = Math.max(build(arr,ss,mid,si*2+1),build(arr,mid+1,se,si*2+2));
			return amp[si];
		}
		public void update(int ss, int se, int i, long l, int si){
			if(i<ss||i>se) return;
			if(se==ss) {
				amp[si] = -1;
				return;
			}
			if(se!=ss){
				int mid = (ss+se)/2;
				update(ss,mid,i,l,2*si+1);
				update(mid+1,se,i,l,2*si+2);
			}
			amp[si] = Math.max(amp[si*2+1], amp[si*2+2]);
			
		}
		public int getSum(int ss,int se, int s, int e, int si){
			if(s<=ss && se<=e) return amp[si];
			if(s>se||e<ss) return -1;
			int mid = (ss+se)/2;
			return Math.max(getSum(ss,mid,s,e,2*si+1),getSum(mid+1,se,s,e,2*si+2));
		}
		public void print(){
			for(int i = 0;i<size;i++) System.out.print(amp[i]+" ");
		}
	}
	public static int ans(int x1,int x2, int y1, int y2){
		return (Math.abs(x1-x2)+Math.abs(y1-y2)+Math.abs(x1-y2)+Math.abs(y1-x2));
	}
	public static long gcd(long a, long b){
		if(b==0) return a;
		else return gcd(b,a%b);
	}
	public static void seive(){
		
		hs.add(1);
		for(int i = 2;i*i<=b.length;i++){
			if(b[i]){
				
				hs.add(i);
				for(int p = 2*i;p<b.length;p+=i){
					b[p]= false;
				}
			}
		}
	}
	public static void stringReverse(int s, int e){
		int i = s, j =e;
		char ch[] = s2.toString().toCharArray();
		while(i<j){
			char c = ch[i];
			ch[i] = ch[j];
			ch[j] = c;
			i++;j--;
		}
		s2.delete(0, s2.length());
		for(int x =0 ;x<ch.length;x++) s2.append(ch[x]);
	}
	public static void buildGraph(int m){
		for(int i = 0; i<m;i++){
			int x = sc.nextInt();
			int y = sc.nextInt();
			amp[--x].add(--y);
			amp[y].add(x);
		}
	}
	public static boolean isPalindrome(String str){
	    int cnt = 0;
	    int arr[] = new int[26];
		for(int i =0;i<str.length();i++){
	        arr[str.charAt(i)-'a']++;
	    }
		for(int i = 0;i<26;i++){
			if(arr[i]%2==0) continue;
			else cnt++;
		}
		if(cnt<2)
	    return true;
		return false;
	}
	public static void dfs(int x,HashMap<Integer,Integer> hm){
		b[x] = true;
		if(hm.containsKey(arr[x]-1)) hm.put(arr[x]-1, hm.get(arr[x]-1)+1);
		else{
			hm.put(arr[x]-1, 1);
		}
		cnt++;
		for(int i =0;i<amp[x].size();i++){
			if(!b[amp[x].get(i)]) dfs(amp[x].get(i),hm);
		}
	}
	
	public static void mergeSort(int[] arr, int start, int end){
		
		if(start<end){
			int mid = (start+end)/2;
			mergeSort(arr,start,mid);
			mergeSort(arr,mid+1,end);
		merge(arr,start,mid,end);
		}
	}
	public static void merge(int arr[],int start, int mid, int end){
		int left[] = new int[mid-start+1];
		int right[] = new int[end-mid];
		for(int i= 0;i<mid-start+1;i++){
			left[i] = arr[i+start];
			//System.out.println(left[i-start]);
		}
		for(int i = 0;i<end-mid;i++){
			right[i] = arr[i+mid+1];
			//System.out.println(right[i-mid]+"*");
		}
		int k = start, i =0, j = 0;
		while(i<mid-start+1 && j<end-mid){
			if(left[i]<right[j]){
				arr[k++] = left[i];
				i++;
			}
			else{
				arr[k++] = right[j];
				j++;
			}
			
		}
		while(i<mid-start+1) {
			arr[k++] = left[i];i++;
		}
		while(j<end-mid) {
			arr[k++] = right[j];j++;
		}
	}
	
	
		
	public static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

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

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

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

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
	        
	    public int[] nextIntArray(int n) {
	        return nextIntArray(n, 0);
	    }
	    
	    public int[] nextIntArray(int n, int off) {
	    	int[] arr = new int[n + off];
	    	for (int i = 0; i < n; i++) {
	    		arr[i + off] = nextInt();
	    	}
	    	return arr;
	    }
	    
	    public long[] nextLongArray(int n) {
	    	return nextLongArray(n, 0);
	    }
        
		public long[] nextLongArray(int n, int off) {
		    long[] arr = new long[n + off];
		    for (int i = 0; i < n; i++) {
		        arr[i + off] = nextLong();
		    }
		    return arr;
		}

	    private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}


}
