Problem: 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.

Solution (in JAVA):

Solution:
	                            import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;
	
	
	
	                                            public class Solution1 implements Runnable
	                                            {
	                                                static final long MAX = 464897L;
	                                                static class InputReader
	                                                {
	                                                    private InputStream stream;
	                                                    private byte[] buf = new byte[1024];
	                                                    private int curChar;
	                                                    private int numChars;
	                                                    private SpaceCharFilter filter;
	                                                    private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	                                             
	                                                    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 String nextLine()
	                                                    {
	                                                        String str = "";
	                                                        try
	                                                        {
	                                                            str = br.readLine();
	                                                        }
	                                                        catch (IOException e)
	                                                        {
	                                                            e.printStackTrace();
	                                                        }
	                                                        return str;
	                                                    }
	                                                    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 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 double nextDouble() 
	                                                    {
	                                                        int c = read();
	                                                        while (isSpaceChar(c))
	                                                            c = read();
	                                                        int sgn = 1;
	                                                        if (c == '-') 
	                                                        {
	                                                            sgn = -1;
	                                                            c = read();
	                                                        }
	                                                        double res = 0;
	                                                        while (!isSpaceChar(c) && c != '.') 
	                                                        {
	                                                            if (c == 'e' || c == 'E')
	                                                                return res * Math.pow(10, nextInt());
	                                                            if (c < '0' || c > '9')
	                                                                throw new InputMismatchException();
	                                                            res *= 10;
	                                                            res += c - '0';
	                                                            c = read();
	                                                        }
	                                                        if (c == '.') 
	                                                        {
	                                                            c = read();
	                                                            double m = 1;
	                                                            while (!isSpaceChar(c)) 
	                                                            {
	                                                                if (c == 'e' || c == 'E')
	                                                                    return res * Math.pow(10, nextInt());
	                                                                if (c < '0' || c > '9')
	                                                                    throw new InputMismatchException();
	                                                                m /= 10;
	                                                                res += (c - '0') * m;
	                                                                c = read();
	                                                            }
	                                                        }
	                                                        return res * sgn;
	                                                    }
	                                                    
	                                                    public String readString() 
	                                                    {
	                                                        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 boolean isSpaceChar(int c) 
	                                                    {
	                                                        if (filter != null)
	                                                            return filter.isSpaceChar(c);
	                                                        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	                                                    }
	                                                 
	                                                    public String next() 
	                                                    {
	                                                        return readString();
	                                                    }
	                                                    
	                                                    public interface SpaceCharFilter 
	                                                    {
	                                                        public boolean isSpaceChar(int ch);
	                                                    }
	                                                }
	                                                 
	                                                public static void main(String args[]) throws Exception
	                                                {
	                                                    new Thread(null, new Solution1(),"Solution",1<<26).start();
	                                                }    
	                                                public static int gcd(int a, int b)
	                                                {
	                                                    if (a == 0)
	                                                        return b;
	                                                     
	                                                    return gcd(b%a, a);
	                                                }
	                                                int lcm(int a, int b)
	                                                {
	                                                    return (a*b)/gcd(a, b);
	                                                }
	                                                ArrayList<Integer> adj[];
	                                                ArrayList<Integer> adj1[];
	                                                static long MOD = 1000000007;
	                                                int[] dx = {1,-1,0,0};
	                                                int[] dy = {0,0,1,-1};
	                                                int MAXN = 100005;
	                                                long[] val;
	                                                public void run() 
	                                                {
	                                                    
	                                                        //InputReader sc= new InputReader(new FileInputStream("input.txt"));
	                                                        //PrintWriter w= new PrintWriter(new FileWriter("output.txt"));
	                                                        InputReader sc = new InputReader(System.in);
	                                                        PrintWriter w = new PrintWriter(System.out);
	                                                        int n = sc.nextInt();
	                                                        int m = sc.nextInt();
	                                                        StringBuilder st = new StringBuilder();
	                                                        StringBuilder st2 = new StringBuilder();
	                                                        //st2.append("9");
	                                                        for(int i = 0;i < n;i++) {
	                                                        	st.append("1");
	                                                        	if(i == n-1)
	                                                        		st2.append("9");
	                                                        	else
	                                                        		st2.append("8");
	                                                        }
	                                                        w.println(st.toString());
	                                                        w.println(st2.toString());
	                                                        w.close();	                                                                                                                      
	                                                 }
	                                                
	                                                boolean[] visited;
	                                                ArrayList<ArrayList<Integer>> ar = new ArrayList();
	                                                ArrayList<Integer> temp;
	                                                void dfs1(int a) {
	                                                	visited[a] = true;
	                                                	Iterator<Integer> it = adj1[a].iterator();
	                                                	while(it.hasNext()) {
	                                                		int x = it.next();
	                                                		if(!visited[x]) {
	                                                			dfs1(x);
	                                                		}
	                                                	}
	                                                	temp.add(a);
	                                                }
	                                                void topo() {
	                                                	for(int i = 0;i < adj.length;i++) {
	                                                		if(!visited[i]) {
	                                                			dfs(i);
	                                                		}
	                                                	}
	                                                }
	                                                Stack<Integer> st=  new Stack();
	                                                void dfs(int a) {
	                                                	visited[a] = true;
	                                                	Iterator<Integer> it = adj[a].iterator();
	                                                	while(it.hasNext()) {
	                                                		int x = it.next();
	                                                		if(!visited[x]) {
	                                                			dfs(x);
	                                                		}
	                                                	}
	                                                	st.add(a);
	                                                }
	                                               
	                                                ArrayList<Integer> pr = new ArrayList();
	                                                void sieve() {
	                    								boolean[] prime = new boolean[MAXN];
	                    								Arrays.fill(prime, true);
	                    								prime[1] = false;
	                    								for(int i = 2;i < MAXN;i++) {
	                    									if(prime[i]) {
	                    										for(int j = 2*i;j < MAXN;j+=i) {
	                    											prime[j] = false;
	                    										}
	                    									}
	                    								}
	                    								for(int i =2;i < MAXN;i++) {
	                    									if(prime[i]) {
	                    										pr.add(i);
	                    									}
	                    								}
	                    							}
	                                                TreeSet<Integer> factorize(int a) {
	                                                	TreeSet<Integer> ar = new TreeSet();
	                                                	while(a != 1) {
	                                                		ar.add(spf[a]);
	                                                		a = a/spf[a];
	                                                	}
	                                                	return ar;
	                                                }
	                    							int[] spf;
	                                                static class Pair implements Comparable<Pair>{
	                                                    int a;
	                                                    int b;
	                                                    
	                                                    
	                                                    Pair(int a,int b){
	                                                        this.a  =a;
	                                                        this.b = b;
	                                                        
	                                                    }
	                                                    Pair(){}    
	                                                    public boolean equals(Object o)
	                                                    {
	                                                        Pair p = (Pair)o;
	                                                        return (this.a == p.a && this.b == p.b) || (this.a == p.b && this.b == p.a);
	                                                    }
	                                                    
	                                                    public int compareTo(Pair p){
	                                                    	 return Integer.compare(this.b, p.b);
	                                                    }
	                                                    public int hashCode()
	                                                    {
	                                                        return new Long(a).hashCode()*31 + new Long(b).hashCode()*2 + new Long(a).hashCode() * 3;
	                                                    }
	
	                                                }
	                                                
	                                }