Eighth-grader Vova is on duty today in the class. After classes, he went into the office to wash the board, and found on it the number n. He asked what is this number and the teacher of mathematics Inna Petrovna answered Vova that n is the answer to the arithmetic task for first-graders. In the textbook, a certain positive integer x was given. The task was to add x to the sum of the digits of the number x written in decimal numeral system.

Since the number n on the board was small, Vova quickly guessed which x could be in the textbook. Now he wants to get a program which will search for arbitrary values of the number n for all suitable values of x or determine that such x does not exist. Write such a program for Vova.

Input

The first line contains integer n (1 ≤ n ≤ 109).

Output

In the first line print one integer k — number of different values of x satisfying the condition. 

In next k lines print these values in ascending order.

Examples

Input

21


Output

1
15


Input

20


Output

0

Note

In the first test case x = 15 there is only one variant: 15 + 1 + 5 = 21.

In the second test case there are no such x.

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;

public class workspace {
	
	
	
	
	/*
	 * 1000000000
	 * 999999979
	 * 99999900
	 */

	public static void main(String[] args) {

		InputReader in = new InputReader(System.in);
		OutputWriter out = new OutputWriter(System.out);
		Scanner scan = new Scanner(System.in);
		
		ArrayList<Integer> arr =  new ArrayList<Integer>();		
		int input =  in.readInt();
		
		int checkNoOfDigits = input;
//		int totalDigits =0;
//		String s = "";
//		while (checkNoOfDigits/10!=0) {
//			totalDigits = totalDigits + 1;
//			checkNoOfDigits /=10;
//			s = s + "9";
//		}
//		
//
		int checker = 0;
//		long limit=0; 
//		if (s != "") {
//			limit = Integer.parseInt(s);
//		}
//		
//		limit = limit - 99;

		for (int i=input-1;i>input-81;i--) {
			checker = i;
			int digits = i;
			
			while (digits!=0) {
				checker = checker + digits%10;
				digits = digits/10;
			}
			
			if (checker == input) {
				arr.add(i);
			}
		}
		
		out.printLine(arr.size());
		
		for (int i=arr.size()-1;i>=0;i--) {
			out.printLine(arr.get(i)	);
		}
		
		out.close();
}
	
	private static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

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

		public long readLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			long 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 readInt() {
			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 String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuffer res = new StringBuffer();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

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

		public String next() {
			return readString();
		}
	}

	private static class OutputWriter {
		private final PrintWriter writer;

		public OutputWriter(OutputStream outputStream) {
			writer = new PrintWriter(outputStream);
		}

		public OutputWriter(Writer writer) {
			this.writer = new PrintWriter(writer);
		}

		public void print(Object... objects) {
			for (int i = 0; i < objects.length; i++) {
				if (i != 0)
					writer.print(' ');
				writer.print(objects[i]);
			}
		}

		public void printLine(Object... objects) {
			print(objects);
			writer.println();
		}

		public void close() {
			writer.close();
		}
	}
}

class graph {

	public class Node {

		public int x, y;

		public Node(int x, int y) {
			this.x = x;
			this.y = y;
		}

	}

	private LinkedList<Node> abj[];
	private int size;

	graph(int size) {
		this.size = size;
		abj = new LinkedList[this.size];

		for (int i = 0; i < this.size; i++) {
			abj[i] = new LinkedList<Node>();
		}
	}

	void addVertex(Node a, Node b) {

		abj[a.x].add(b);
	}

	public void dfs(Node source, int[] cats) {

		boolean visited[] = new boolean[this.size];

		if (cats[source.x] == 1) {
			source.y--;
		}
		visited[source.x] = true;

		dfsUtil(visited, cats, source);
	}

	int count = 0;

	private void dfsUtil(boolean[] visited, int[] cats, Node parent) {

		Iterator<Node> i = abj[parent.x].iterator();

		while (i.hasNext()) {

			Node x = i.next();
			int flag = 0;
			if (!visited[x.x] && cats[x.x] == 1) {
				x.y = parent.y;
				x.y--;
			}
			if (!visited[x.x] && x.y >= 0) {
				visited[x.x] = true;
				flag = 1;
				dfsUtil(visited, cats, x);

			}

			Iterator<Node> a = abj[x.x].listIterator();

			if (!a.hasNext() && flag == 1) {
				count++;
			}

		}

	}
}