from itertools import combinations, combinations_with_replacement, product

def list_adder(strings, number):
    l = len(strings[0]) + 1
    lis = [string[:i] + str(number) + string[i:] for string in strings for i in range(l)]
    return lis

def permuter(lis1, lis2):
    while lis1:
        n = lis1.pop()
        lis2 = list_adder(lis2, n)
    return set(lis2)

def lis_to_str(list1):
    return ''.join(map(str, list1))

def lis_to_int(list1):
    return int(''.join(map(str, list1)))

def main():
    item = input().split()
    n = int(item[0])
    k = int(item[1])

    li1 = list(combinations_with_replacement(range(1, 10), r=k))
    li2 = list(product(range(10), repeat=n-k))
    li2.remove((0,) * (n - k))

    answers = set()
    li3 = []

    for i in li1:
        li4 = []
        for j in li2:
            li4 += [(lis_to_int(j), int(i)) for i in permuter(list(i), [lis_to_str(j)]) if i[0] != '0']
        li3.append(li4)

    for i in li3:
        for item in combinations(i, r=2):
            if item[0][0] < item[1][0] and item[0][0] * item[1][1] == item[1][0] * item[0][1]:
                answers.add((item[0][1], item[1][1]))

    print(sum(a[0] for a in answers), sum(a[1] for a in answers))

if __name__ == "__main__":
    main()

import java.io.*;
import java.util.*;

public class Solution {

    private static char[] insert(char[] array, int count, char target) {
        char[] in_new = new char[array.length + count];
        for(int k = 0; k < count; k++) {
            in_new[k] = target;
        }
        for(int k = count; k < in_new.length; k++) {
            in_new[k] = array[k - count];
        }
        return in_new;
    }
    
    public static boolean nextPermutation(char[] array) {
        for(int i = array.length - 1; i > 0; i--) {
            if(array[i - 1] < array[i]) {
                int dest = array[i - 1];
                int s = i;
                int e = array.length - 1;
                int swapIndex = 0;
                while(true) {
                    if(s == e) {
                        swapIndex = s;
                        break;
                    }
                    int m = (s + e + 1) / 2;
                    if(array[m] <= dest) {
                        e = m - 1;
                    } else {
                        s = m;
                    }
                }
                char temp = array[swapIndex];
                array[swapIndex] = array[i - 1];
                array[i - 1] = temp;
                Arrays.sort(array, i, array.length);
                return true;
            }
        }
        return false;
    }
    
    private static char[] NumToCharArray(int x, int digits) {
        String result = String.valueOf(x);
        while(result.length() != digits) {
            result = "0" + result;
        }
        return result.toCharArray();
    }
    
    private static int merge(char[] strFill, char[] mask) {
        int index = 0;
        int result = 0;
        for(char m : mask) {
            result *= 10;
            if(m == '.') {
                result += strFill[index] - '0';
                index++;
            } else {
                result += Character.getNumericValue(m);
            }
        }
        
        return result;
    }
    
    public static void main(String[] args) {
        try(Scanner sc = new Scanner(System.in)) {
            int N = sc.nextInt();
            int K = sc.nextInt();
            int keep = N - K;
            int[] Tens = {1, 10, 100, 1000, 10000};
            int sumN = 0;
            int sumD = 0;
            HashSet<Integer> used = new HashSet<>();
            for(int d = 1; d < Tens[keep]; d++) {
                for(int n = 1; n < d; n++) {
                    char[] charN = NumToCharArray(n, keep);
                    char[] charD = NumToCharArray(d, keep);
                    for(int i = Tens[K - 1]; i < Tens[K]; i++) {
                        char[] in = NumToCharArray(i, K);
                        boolean isAscending = true;
                        for(int j = 1; j < in.length; j++) {
                            if(in[j - 1] > in[j]) {
                                isAscending = false;
                                break;
                            }
                        }
                        if(isAscending) {
                            in = insert(in, keep, '.');
                            char[] charInsertN = in.clone();
                            do {
                                int newN = merge(charN,
                                                 charInsertN);
                                if(newN >= Tens[N - 1]) {
                                    char[] charInsertD = in.clone();
                                    do {
                                        int newD = merge(charD,
                                                         charInsertD);
                                        if(newN * d == newD * n) {
                                            int id =   newN
                                                     * 10000
                                                     + newD;
                                            if(!used.contains(id)) {
                                                sumN += newN;
                                                sumD += newD;
                                                used.add(id);
                                            }
                                        }
                                    } while(nextPermutation
                                               (charInsertD));
                                }
                            } while(nextPermutation
                                       (charInsertN));
                        }
                    }
                }
            }
            System.out.println(sumN + " " + sumD);
        }
    }
}

import itertools
def list_adder(strings,number):
    '''Create all possible strings with number added at all indices in string in strings'''
    l=len(strings[0])+1 #+1, because I also have to add number at last position 
    lis=[string[:i]+str(number)+string[i:] for string in strings for i in range(l)]
    return lis

def permuter(lis1,lis2):
    '''It creates all possible permutations with lis1 as unordered and lis2 as ordered'''
    while lis1:
        n=lis1.pop()
        lis2=list_adder(lis2,n)
    return set(lis2)

def lis_to_str(list1):
    '''Take in a sequence of numbers and returns a str of them'''
    return ''.join([str(no) for no in list1])

def lis_to_int(list1):
    '''Take in a sequence of numbers and return int formed by combining them'''
    return int(''.join([str(no) for no in list1]))

item=input().split()
n=int(item[0])
k=int(item[1])

li1=list(itertools.combinations_with_replacement(range(1,10),r=k)) #This is the list of possible combinations of numbers which are common in numerator and denominator

li2=list(itertools.product(range(10),repeat=n-k)) #The ordered combinations of other digits in numerator or denominator
li2.remove((0,)*(n-k)) # after cancelling common digits we should'nt be left with something like 00/00 or 00/12 etc

answers=set() #so that I don't count repeated fractions
li3=[] # it contains for a particular element in li all the possible casses of elements in li2 with the numerator or denominator as in the format (12,1234) all stored in a list
for i in li1:
    li4=[]
    for j in li2:
        li4+=[(lis_to_int(j),int(i)) for i in permuter(list(i),[lis_to_str(j)]) if i[0]!='0'] # we should'nt get number like 0123 for n=4
    li3.append(li4)

for i in li3:
    for item in itertools.combinations(i,r=2): # I just used combinations instead of permutations cause the left over numerator should be less than left over denominator and the storing order was lexicographical
        if item[0][0]<item[1][0] and item[0][0]*item[1][1]==item[1][0]*item[0][1]:
            answers.add((item[0][1],item[1][1]))

print(sum([a[0] for a in answers]), sum([a[1] for a in answers]))