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.*;

public class Example {
    static long[][] dp;
    //  static    int[]  ar;
    static int mod = 1000000000 + 7;
    static long[] ans = new long[100000 + 1];
    static List<List<Integer>> adj;
    static int[] vis;
    static int[] dis;
    static int row;
    static boolean[] chosen;
    static  List<Integer> permutation;
    static int k;
    static  int count;
    static  int[][] arr;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
//good morning
int n =sc.nextInt();
int m=sc.nextInt();
StringBuilder a1=new StringBuilder();
StringBuilder a2=new StringBuilder();
for(int i=1;i<=300;i++){
    a1.append(5);
    if(i!=300)
    a2.append(4);
    else
        a2.append(5);

}
        System.out.println(a1+" "+a2);

    }

    private static int ncr(int notsure, int i) {
        int a=1;
        a=(factorail(notsure))/(factorail(notsure-1)*(factorail(i)));
        return a;
    }

    private static int factorail(int notsure) {
        int fac=1;
        for(int i=2;i<=notsure;i++){
            fac=fac+i;
        }
        return fac;

    }

    private static void allPerMutation(int n) {
        if(permutation.size()==n){
            //   System.out.println(permutation);
            long sum=arr[1][permutation.get(0)];
            for(int i=0;i<permutation.size()-1;i++){
                sum+=arr[permutation.get(i)][permutation.get(i+1)];
            }
            sum=sum+arr[permutation.get(n-1)][1];
            if(sum==k){
                count++;
            }

        }else{
            for(int i=2;i<=(n+1);i++){
                if(chosen[i]){
                    continue;
                }
                permutation.add(i);
                chosen[i]=true;
                allPerMutation(n);
                permutation.remove(permutation.size()-1);
                chosen[i]=false;
            }


        }




    }


    public static int Check(int[] arr,int k){
        int sum=0;
        int j=1;
        int total=0;
        for(int i=1;i<arr.length;i++){
            sum+=arr[i];
            if(sum==k){
                total+=(i-j);
                j=i+1;
                sum=0;
            }if(sum>k){
                return arr.length;
            }
        }
        return total;


    }








    private static long findans(int[] arr, int i, int s) {
        if (i < 0 && s == 0)
            return 0;
        if (i < 0 && s == 1)
            return 0;
        if (dp[i][s] != -1) {
            return dp[i][s];
        } else {


            if (s == 0)
                return dp[i][s] = Math.max(findans(arr, i - 1, s), -1 * arr[i] + findans(arr, i - 1, 1 - s));
            else
                return dp[i][s] = Math.max(findans(arr, i - 1, s), arr[i] + findans(arr, i - 1, 1 - s));
        }
    }

    public static void dfs(int v, int di) {
        dis[v] = di;
        vis[v] = 1;
        for (int i = 0; i < adj.get(v).size(); i++) {
            int x = adj.get(v).get(i);
            if (vis[x] == 0) {
                dfs(x, di + 1);
            }
        }
    }

    private static boolean isPrime(long a) {
        if (a == 1)
            return true;

        for (int i = 2; i * i <= a; i++) {
            if (a % i == 0)
                return false;

        }
        return true;
    }

    private static int gcd(int aa, int bb) {
        if (bb == 0)
            return aa;
        return gcd(bb, aa % bb);

    }

    private static int lowerBound(int[] ar, int a) {
        int res = 0;
        int s = 1;
        int e = ar.length - 1;
        while (s <= e) {
            int mid = (s) + (e - s) / 2;
            if (ar[mid] <= a) {
                res = mid;
                s = mid + 1;

            } else {
                e = mid - 1;
            }
        }
        return res;
    }

    public static int getXORSum(int[] arr1, int[] arr2) {

        long c = 0;
        int n = arr1.length;
        int m = arr2.length;
        if (n == 1 && m == 1) {
            return arr1[0] & arr2[0];
        }
        int aa = n + m;
        for (int i = 0; i < 32; i++) {

            int z = 0;
            int o = 0;
            int cc = 0;
            for (int a : arr1) {


                int x = (a & (1 << i));
                if (x == 0)
                    z++;
                else
                    o++;


            }
            for (int a : arr2) {
                int x = (a & (1 << i));
                if (x == 0)
                    z++;
                else
                    o++;
            }

            System.out.println(z + " " + o);

            if (z != aa && o != aa) {
                c = c + (1 << i);

            }


        }
        return (int) c;


    }


}