Let s(x) be sum of digits in decimal representation of positive integer x. Given two integers n and m, find some positive integers a and b such that 

  * s(a) ≥ n, 
  * s(b) ≥ n, 
  * s(a + b) ≤ m. 

Input

The only line of input contain two integers n and m (1 ≤ n, m ≤ 1129).

Output

Print two lines, one for decimal representation of a and one for decimal representation of b. Both numbers must not contain leading zeros and must have length no more than 2230.

Examples

Input

6 5


Output

6 
7


Input

8 16


Output

35 
53

Note

In the first sample, we have n = 6 and m = 5. One valid solution is a = 6, b = 7. Indeed, we have s(a) = 6 ≥ n and s(b) = 7 ≥ n, and also s(a + b) = s(13) = 4 ≤ m.
import java.util.Arrays;
import java.util.HashMap;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class Solve {
	public static void main(String[] args) throws IOException {
		PrintWriter out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);
		int n =sc.nextInt();
		int m =sc.nextInt();
		int a[]= new int[n];
		int b[]= new int[n];
		for(int i=n-1;i>=0;i--)
		{
			a[i]=1;
			if(i==n-1)
				b[i]=9;
			else
				b[i]= 8 ;
		}
		for(int i=0;i<a.length;i++)
			out.print(a[i]);
		out.println();
		for(int i=0;i<a.length;i++)
			out.print(b[i]);
		out.close();
		
		
	}

	static boolean IsTrusted(int node, int[][] trustGraph, int[] pretrustedPeers, int trustThreshold) {
		for (int i = 0; i < pretrustedPeers.length; i++)
			if (pretrustedPeers[i] == node) {
				return true;
			}
		int distances[] = dijkstra_GetMinDistances(node, trustGraph);
		for (int i = 0; i < pretrustedPeers.length; i++)
			if (distances[pretrustedPeers[i]] <= trustThreshold)
				return true;
		return false;
	}

	static int getMinimumVertex(boolean[] mst, int[] key, int vertices) {
		int minKey = Integer.MAX_VALUE;
		int vertex = -1;
		for (int i = 0; i < vertices; i++) {
			if (mst[i] == false && minKey > key[i]) {
				minKey = key[i];
				vertex = i;
			}
		}
		return vertex;
	}

	public static int[] dijkstra_GetMinDistances(int sourceVertex, int[][] trustGraph) {
		int vertices = trustGraph.length;
		boolean[] spt = new boolean[vertices];
		int[] distance = new int[vertices];
		int INFINITY = Integer.MAX_VALUE;

		// Initialize all the distance to infinity
		for (int i = 0; i < vertices; i++) {
			distance[i] = INFINITY;
		}

		// start from the vertex 0
		distance[sourceVertex] = 0;

		// create SPT
		for (int i = 0; i < vertices; i++) {

			// get the vertex with the minimum distance
			int vertex_U = getMinimumVertex(spt, distance, vertices);

			// include this vertex in SPT
			spt[vertex_U] = true;

			// iterate through all the adjacent vertices of above vertex and update the keys
			for (int vertex_V = 0; vertex_V < vertices; vertex_V++) {
				// check of the edge between vertex_U and vertex_V
				if (trustGraph[vertex_U][vertex_V] > 0) {
					// check if this vertex 'vertex_V' already in spt and
					// if distance[vertex_V]!=Infinity

					if (spt[vertex_V] == false && trustGraph[vertex_U][vertex_V] != INFINITY) {
						// check if distance needs an update or not
						// means check total weight from source to vertex_V is less than
						// the current distance value, if yes then update the distance

						int newKey = trustGraph[vertex_U][vertex_V] + distance[vertex_U];
						if (newKey < distance[vertex_V])
							distance[vertex_V] = newKey;
					}
				}
			}
		}
		// print shortest path tree
		return printDijkstra(distance);
	}

	private static int[] printDijkstra(int[] distance) {
		for (int i = 0; i < distance.length; i++)
			System.out.println(distance[i]);

		return distance;

	}

}

class ListNode {
	int val;
	ListNode next;

	ListNode(int x) {
		val = x;
	}
}

class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s) {
		br = new BufferedReader(new InputStreamReader(s));
	}

	public Scanner(String f) throws FileNotFoundException {
		br = new BufferedReader(new FileReader(f));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

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

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

	public String nextLine() throws IOException {
		return br.readLine();
	}

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

	public boolean ready() throws IOException {
		return br.ready();
	}

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

	public int[] nextIntArray1(int n) throws IOException {
		int[] a = new int[n + 1];
		for (int i = 1; i <= n; i++)
			a[i] = nextInt();
		return a;
	}

	public int[] shuffle(int[] a, int n) {
		int[] b = new int[n];
		for (int i = 0; i < n; i++)
			b[i] = a[i];
		Random r = new Random();
		for (int i = 0; i < n; i++) {
			int j = i + r.nextInt(n - i);
			int t = b[i];
			b[i] = b[j];
			b[j] = t;
		}
		return b;
	}

	public int[] nextIntArraySorted(int n) throws IOException {
		int[] a = nextIntArray(n);
		a = shuffle(a, n);
		Arrays.sort(a);
		return a;
	}

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

	public long[] nextLongArray1(int n) throws IOException {
		long[] a = new long[n + 1];
		for (int i = 1; i <= n; i++)
			a[i] = nextLong();
		return a;
	}

	public long[] nextLongArraySorted(int n) throws IOException {
		long[] a = nextLongArray(n);
		Random r = new Random();
		for (int i = 0; i < n; i++) {
			int j = i + r.nextInt(n - i);
			long t = a[i];
			a[i] = a[j];
			a[j] = t;
		}
		Arrays.sort(a);
		return a;
	}
}
