For a given positive integer n denote its k-rounding as the minimum positive integer x, such that x ends with k or more zeros in base 10 and is divisible by n.For example, 4-rounding of 375 is 375·80 = 30000. 30000 is the minimum integer such that it ends with 4 or more zeros and is divisible by 375.Write a program that will perform the k-rounding of n.

The only line contains two integers n and k (1 ≤ n ≤ 109, 0 ≤ k ≤ 8).

/**
 * Date: 12 Mar, 2018
 * Link :
 *
 * @author Prasad-Chaudhari
 * @email prasadc8897@gmail.com
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class New_File_1 {

    public static void main (String[] args) throws java.lang.Exception {
        FastIO2 in = new FastIO2();
        long n = in.ni();
        int k = in.ni();
        long p = (long)Math.pow(10,k);
        GCD g = new GCD();
        long q = g.calc_gcd(n,p);
        System.out.println(n*p/q);
    }

    static class FastIO2 {

        private final BufferedReader br;
        private String s[];
        private int index;

        public FastIO2() throws IOException {
            br = new BufferedReader(new InputStreamReader(System.in));
            index = 0;
        }

        public int ni() throws IOException {
            return Integer.parseInt(nextToken());
        }

        public double nd() throws IOException {
            return Double.parseDouble(nextToken());
        }

        public long nl() throws IOException {
            return Long.parseLong(nextToken());
        }

        public String next() throws IOException {
            return nextToken();
        }

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

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

        public int[] gia(int n, int start, int end) throws IOException {
            validate(n, start, end);
            int a[] = new int[n];
            for (int i = start; i < end; i++) {
                a[i] = ni();
            }
            return a;
        }

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

        public double[] gda(int n, int start, int end) throws IOException {
            validate(n, start, end);
            double a[] = new double[n];
            for (int i = start; i < end; i++) {
                a[i] = nd();
            }
            return a;
        }

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

        public long[] gla(int n, int start, int end) throws IOException {
            validate(n, start, end);
            long a[] = new long[n];
            for (int i = start; i < end; i++) {
                a[i] = ni();
            }
            return a;
        }

        private String nextToken() throws IndexOutOfBoundsException, IOException {
            if(s == null){
                s = br.readLine().split(" ");
            }
            if (index == s.length) {
                s = br.readLine().split(" ");
                index = 0;
            }
            return s[index++];
        }

        private void validate(int n, int start, int end) {
            if (start < 0 || end >= n) {
                throw new IllegalArgumentException();
            }
        }
    }
}

/**
 * Source : https://www.geeksforgeeks.org/multiplicative-inverse-under-modulo-m/
 * @author PRASAD
 */
class GCD {

    public GCD() {
        // Sry Nothing to initalise
    }

    public long a_inv_b(long a, long m) {
        if (gcd(a, m) == 1) {
            long m0 = m;
            long y = 0, x = 1;
            if (m == 1) {
                return 0;
            }
            while (a > 1) {
                long q = a / m;
                long t = m;
                m = a % m;
                a = t;
                t = y;
                y = x - q * y;
                x = t;
            }
            if (x < 0) {
                x += m0;
            }
            return x;
        } else {
            return -1;
        }
    }

    public int calc_gcd(int a, int b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return (int) gcd(a, b);
    }

    public long calc_gcd(long a, long b) {
        if (b > a) {
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
        }
        return gcd(a, b);
    }

    private long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        long gcd = gcd(b, a % b);
        return gcd;
    }
}

/*
 * http://codeforces.com/problemset/problem/858/A
 */

/*  Basic import definitions    */
    import java.util.*;
    import java.math.BigInteger;
    import java.util.LinkedList;

/*  Basic Class definitions*/
    public class kRounding
    {
        public static void main(String[] args)
        {
            Scanner sc = new Scanner(System.in);

            int i , j , k;
            int t,N;
            i=0;
            j=0;
            int min = 0;
            N = Integer.parseInt(sc.next());
            k = Integer.parseInt(sc.next());
            int m = N;
            BigInteger cat;
            t=1;

            while(m%2 == 0)
            {
                i++;
                m/=2;
            }
            m=N;
            min = i;
            while(m%5 == 0)
            {
                j++;
                m/=5;
            }
            if(j<min)
                min = j;

            //System.out.println("i " + i + " j " + j + " min " +min);

            cat = BigInteger.valueOf(N);

            if(min >= k)
                System.out.println(N);

            else
            {
                i-= min;
                j-= min;
                k-= min;

                if(i<0)
                    i=0;
                if(j<0)
                    j=0;

                if(i==0)
                {
                    t = (int)Math.pow(2,k);
                    cat = cat.multiply(BigInteger.valueOf(t));
                    if(k-j < 0)
                        j=k;

                    t = (int)Math.pow(5,k-j);
                    cat = cat.multiply(BigInteger.valueOf(t));
                }
                else
                {
                    if(k-i < 0)
                        i=k;
                    t = (int)Math.pow(2,k-i);
                    cat = cat.multiply(BigInteger.valueOf(t));
                    t = (int)Math.pow(5,k);
                    cat = cat.multiply(BigInteger.valueOf(t));
                }
                System.out.println(cat);
            }
        }
    }

import java.math.BigInteger;
import java.util.*;

public class Main {

    public static void main(String[] args){
        Scanner input = new Scanner(System.in);

        long n = input.nextLong();
        long k = input.nextLong();
        k = (long) Math.pow(10, k);
        for (int i = 1; i <=k; i++) {
            if(k%i==0 && n*i%k==0)
            {
                System.out.println(n*i);
                break;
            }
        }

    }

}

import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class cf1 { //87767777
    static long mod = (long)1e9 + 7;
    static long mod1 = 998244353;
    static FastScanner f;
    static PrintWriter pw = new PrintWriter(System.out);
    static Scanner S = new Scanner(System.in);
    static long x0; static long y0;
    static int inf = (int)(1e9);
    static long iinf = (long)(1e18);
    static void solve()throws NumberFormatException , IOException {
        long n = f.nl(); long k = f.nl();
        long g = gcd(n , pow(10l , k));
        long ans = (n * pow(10l , k)) / g;
        pn(ans);
    }
    public static void main(String[] args)throws NumberFormatException , IOException {
        init();
        int t = 1;
        while(t --> 0) {solve();}
        pw.flush();
        pw.close();
    }

/******************************END OF MAIN PROGRAM*******************************************/
    public static void init()throws IOException{if(System.getProperty("ONLINE_JUDGE")==null){f=new FastScanner("");}else{f=new FastScanner(System.in);}}
    public static class FastScanner {
        BufferedReader br;StringTokenizer st;
        FastScanner(InputStream stream){try{br=new BufferedReader(new InputStreamReader(stream));}catch(Exception e){e.printStackTrace();}}
        FastScanner(String str){try{br=new BufferedReader(new FileReader("!a.txt"));}catch(Exception e){e.printStackTrace();}}
        String next(){while(st==null||!st.hasMoreTokens()){try{st=new StringTokenizer(br.readLine());}catch(IOException e){e.printStackTrace();}}return st.nextToken();}
        String nextLine()throws IOException{return br.readLine();}int ni(){return Integer.parseInt(next());}long nl(){return Long.parseLong(next());}double nd(){return Double.parseDouble(next());}
    }
    public static void pn(Object o){pw.println(o);}
    public static void p(Object o){pw.print(o);}
    public static void pni(Object o){pw.println(o);pw.flush();}
    static int gcd(int a,int b){if(b==0)return a;else{return gcd(b,a%b);}}
    static long gcd(long a,long b){if(b==0l)return a;else{return gcd(b,a%b);}}
    static long lcm(long a,long b){return (a*b/gcd(a,b));}
    static long exgcd(long a,long b){if(b==0){x0=1;y0=0;return a;}long temp=exgcd(b,a%b);long t=x0;x0=y0;y0=t-a/b*y0;return temp;}
    static long pow(long a,long b){long res=1;while(b>0){if((b&1)==1)res=res*a;b>>=1;a=a*a;}return res;}
    static long mpow(long a,long b){long res=1;while(b>0l){if((b&1)==1l)res=((res%mod)*(a%mod))%mod;b>>=1l;a=((a%mod)*(a%mod))%mod;}return res;}
    static long mul(long a , long b){return ((a%mod)*(b%mod)%mod);}
    static long adp(long a , long b){return ((a%mod)+(b%mod)%mod);}
    static int log2(int x){return (int)(Math.log(x)/Math.log(2));}
    static boolean isPrime(long n){if(n<=1)return false;if(n<=3)return true;if(n%2==0||n%3==0)return false;for(long i=5;i*i<=n;i=i+6)if(n%i==0||n%(i+2)==0)return false;return true;}
    static boolean isPrime(int n){if(n<=1)return false;if(n<=3)return true;if(n%2==0||n%3==0)return false;for(int i=5;i*i<=n;i=i+6)if(n%i==0||n%(i+2)==0)return false;return true;}
    static HashSet<Long> factors(long n){HashSet<Long> hs=new HashSet<Long>();for(long i=1;i<=(long)Math.sqrt(n);i++){if(n%i==0){hs.add(i);hs.add(n/i);}}return hs;}
    static HashSet<Integer> factors(int n){HashSet<Integer> hs=new HashSet<Integer>();for(int i=1;i<=(int)Math.sqrt(n);i++){if(n%i==0){hs.add(i);hs.add(n/i);}}return hs;}
    static HashSet<Long> pf(long n){HashSet<Long> ff=factors(n);HashSet<Long> ans=new HashSet<Long>();for(Long i:ff)if(isPrime(i))ans.add(i);return ans;}
    static HashSet<Integer> pf(int n){HashSet<Integer> ff=factors(n);HashSet<Integer> ans=new HashSet<Integer>();for(Integer i:ff)if(isPrime(i))ans.add(i);return ans;}
    static int[] inpint(int n){int arr[]=new int[n];for(int i=0;i<n;i++){arr[i]=f.ni();}return arr;}
    static long[] inplong(int n){long arr[] = new long[n];for(int i=0;i<n;i++){arr[i]=f.nl();}return arr;}
    static boolean ise(int x){return ((x&1)==0);}static boolean ise(long x){return ((x&1)==0);}
    static int gnv(char c){return Character.getNumericValue(c);}//No. of integers less than equal to i in ub
    static int log(long x){return x==1?0:(1+log(x/2));} static int log(int x){return x==1?0:(1+log(x/2));}
    static int upperbound(int a[],int i){int lo=0,hi=a.length-1,mid=0;int count=0;while(lo<=hi){mid=(lo+hi)/2;if(a[mid]<=i){count=mid+1;lo=mid+1;}else hi=mid-1;}return count;}
    static void sort(int[] a){ArrayList<Integer> l=new ArrayList<>();for(int i:a)l.add(i);Collections.sort(l);for(int i=0;i<a.length;++i)a[i]=l.get(i);}
    static void sort(long[] a){ArrayList<Long> l=new ArrayList<>();for(long i:a)l.add(i);Collections.sort(l);for(int i=0;i<a.length;++i)a[i]=l.get(i);}
    static void sort(ArrayList<Integer> a){Collections.sort(a);}//!Precompute fact in ncr()!
    static int nextPowerOf2(int n){int count=0;if(n>0&&(n&(n-1))==0)return n;while(n!=0){n>>=1;count += 1;}return 1<<count;}
}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class bbg
{
	public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static int vizitat[];
public static int x;

	public static void main (String[] args) throws java.lang.Exception
{

Scanner input=new Scanner(System.in);

HashMap<Integer, Integer> contor1= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> contor2= new HashMap<Integer, Integer>();

HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> stop= new HashMap<Integer, Integer>();

		Long n=input.nextLong();
		Long k=input.nextLong();

		if(k==0) System.out.println(n);

		else if (cifrezero(n)>=k) System.out.println(n);

		else{

		int number=0;
			Long rasp=n;
		int x=0;

		for(int i=1;i<=500000;i++)
		{

		    Long prod=n*i*1L;

	//	 System.out.println(i+" "+prod+" ");

		    if(cifrezero(prod)>number && cifrezero(prod)<=k) {rasp=prod; number=cifrezero(prod);}

		  else   if(cifrezero(prod)==number && prod<rasp ) {rasp=prod;
		    number=cifrezero(prod);}

		}

		System.out.print(rasp);

	for(int j=1;j<=k-cifrezero(rasp);j++) System.out.print("0");

		}

		}

		public static int cifrezero(Long nr){

			Long part=nr;
			int contor=0;
			while(part>0l && part%10==0){
				contor++;
				part=part/10l;

			}

			return contor;

		}

		}

import java.io.*;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Tex_A {
    FastScanner in;
    PrintWriter out;

    public static void main(String[] arg) {
        new Tex_A().run();
    }

    public void solve() throws IOException {
        int n = in.nextInt();
        int k = in.nextInt();
        int a = 0;
        int b = 0;
        long tmp = n;
        while (tmp % 2 == 0) {
            tmp/=2;
            a++;
        }
        tmp = n;
        while (tmp % 5 == 0) {
            tmp/=5;
            b++;
        }
        tmp = n;
        for (int i = 0; i < (k - a); i++) {
            tmp *= 2;
        }
        for (int i = 0; i < (k - b); i++) {
            tmp *= 5;
        }
        out.println(tmp);

    }

    public void run() {
        try {
            in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

            solve();

            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(BufferedReader bufferedReader) {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

    }
}

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

public class Main {
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	private static long mod = 1000000000 + 7;
	private static long mod1 = 1000000000 + 9;
	private static int MAX=1000001;
	private static int block;
	private static LinkedList<Integer> list[];
	private static boolean Visited[];
	private static int count[];

	private static void soln(){
	int N;
	int T,K,a,b,c;
	long x=1;
	T=1;
	while(T>0)
	{
		N=nextInt();
		K=nextInt();
		if(K==0)
			pw.print(N);
		else
		while(K>0)
		{
		a=N%10;
		if(a==0)
		{
			N=N/10;
			K--;
			x=x*10;
		}
		if(a==1 || a==3 || a==7 || a==9)
		{
			x=x*N*(long)Math.pow(10, K);
			K=0;
			N=1;
		}
		if(a==2 || a==4 || a==6 || a==8)
		{
			N=N/2;
			K--;
			x=x*10;
		}
		if(a==5)
		{
			N=N/5;
			K--;
			x=x*10;
		}
		if(K==0)
			pw.print(x*N);

		}

			T--;
	}

	}

	public static int dfs(int x)
	{
		int sum=0;
		int c=0;
		Visited[x]=true;
		for(Integer a:list[x])
		{
			if(!Visited[a])
			{
				dfs(a);
				for(Integer b:list[a])
				{
					if(b!=x)
					if(count[b]==0)
						count[a]=2;
				}

				c=0;
			}
		}

		return 0;
	}

	public static int bfs(int s)
	{
		 int count[] = new int[101];
		 count[100]=-1;
		 boolean Visited[] = new boolean[101];

		int c = 0;
		LinkedList<Integer> queue = new LinkedList<Integer>();

		Visited[s]=true;
		queue.add(s);

		while(queue.size()!=0)
		{

			s=queue.poll();
			c = count[s]+1;
			for(Integer x: list[s])
			{
				if(Visited[x]!=true)
				{
					Visited[x]=true;
					queue.add(x);
					count[x]=c;
				}
			}
		}

		return count[100];

	}

	public static class disjointunion
	{
		int parent[],rank[],number[];
		int n;
	public	disjointunion(int n){
			rank = new int[n];
			parent = new int[n];
			number = new int[n];
			this.n=n;
			makeset();
		}
  void makeset()
  {
	  for(int i=0;i<n;i++)
	  {
		parent[i]=i;
		number[i]=1;
	  }
  }
	int find(int i)
	{
		if(parent[i]!=i)
		{
			parent[i]=find(parent[i]);
		}
			return parent[i];
	}
	void union(int x,int y)
	{
		int xRoot , yRoot;
		xRoot = find(x);
		yRoot = find(y);
		if(xRoot==yRoot)
		return;

		if(rank[xRoot]<rank[yRoot])
		{
			parent[xRoot]=yRoot;
			number[yRoot] += number[xRoot];
			number[xRoot]=0;
		}
		if(rank[xRoot]>rank[yRoot])
		{
			parent[yRoot]=xRoot;
			number[xRoot] += number[yRoot];
			number[yRoot]=0;
		}
		if(rank[xRoot]==rank[yRoot])
		{
			parent[xRoot]=yRoot;
			number[yRoot] += number[xRoot];
			number[xRoot]=0;
			rank[yRoot]++;
		}
	}
	}

	public static void main(String[] args) throws Exception
	{
		new Thread(null,new Runnable()
		{
			@Override
			public void run()
			{
				InputReader(System.in);
				pw = new PrintWriter(System.out);
				soln();
				pw.close();
			}
		},"1",1<<26).start();
	}

	public static void InputReader(InputStream stream1)
	{
		stream = stream1;
	}

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

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

	private static 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++];
	}

	private static 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;
	}

	private static 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;
	}

	private static String nextToken()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	private static int[] nextIntArray(int n)
	{
		int[] arr = new int[n];
		for (int i = 0; i < n; i++)
		{
			arr[i] = nextInt();
		}
		return arr;
	}

	private static long[] nextLongArray(int n)
	{
		long[] arr = new long[n];
		for (int i = 0; i < n; i++)
		{
			arr[i] = nextLong();
		}
		return arr;
	}

	private static void pArray(int[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static void pArray(long[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static boolean isSpaceChar(int c)
	{
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}
	private static char nextChar()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		char c1=(char)c;
		while(!isSpaceChar(c))
			c=read();
		return c1;
	}
	private interface SpaceCharFilter
	{
		public boolean isSpaceChar(int ch);
	}

}

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

public class Codeforces_TechnoCup_2018_KRounding {
    public static void main(String[] args) {
        FScanner input = new FScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out), true);
        long n = input.nextLong();
        long k = input.nextLong();
        long answer = Math.abs(n * (long) Math.pow(10, k)) / gcd(n, (long)Math.pow(10, k));
        out.println(answer);
        out.close();
    }

    static long gcd(long a, long b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    public static PrintWriter out;

    public static class FScanner {
        BufferedReader br;
        StringTokenizer st;

        public FScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        private String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

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

public class A858 {
	public static void main(String args[])throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer str = new StringTokenizer(br.readLine());
		long n = Integer.parseInt(str.nextToken());
		int k = Integer.parseInt(str.nextToken());
		int numTwos = numPowers(n, 2);
		int numFives = numPowers(n, 5);
		int min = Math.min(numTwos, numFives);
		if(min >= k) {
			System.out.println(n);
			return;
		}
		k-=min;
		numFives -= min;
		numTwos -= min;
		if(Math.max(numFives, numTwos) >= k) {
			if(numFives >numTwos) {
				System.out.println((long)n* (long)Math.pow(2, k));
				return;
			}
			else {
				System.out.println((long)n* (long)Math.pow(5, k));
				return;
			}
		} else {
			long aux = 1;
			while(k>0) {
				if(numTwos >0) {
					numTwos --;
					k--;
					aux*=5;
				}
				else if(numFives >0) {
					numFives --;
					k--;
					aux*=2;
				}
				else {
					k--;
					aux*=10;
				}
			}
			System.out.println((long)n*aux);
		}
	}
	public static int numPowers(long n, int x) {
		int result =0;
		while(n>0 && n%x ==0) {
			n/=x;
			result++;
		}
		return result;
	}
}

import java.util.Scanner;
import java.util.Arrays;
public class MarvoloRing {
    public static void main(String[] args) {
        Scanner kbd = new Scanner(System.in);
        String inp = kbd.nextLine();
        String[] input = inp.split(" ");
        long inputOne = Long.parseLong(input[0]);
        long inputTwo = Long.parseLong(input[1]);
        long temp = 1;

        if(inputOne > 0){
        	for(int ctr = 1; ctr <= inputTwo; ctr++){
        			temp *= 10;
        		}
        	System.out.println(inputOne*temp/gcd(temp, inputOne));
        	}
        }

        public static long gcd(long valueOne, long valueTwo){
        	if(valueTwo == 0){
        		return valueOne;
        	}else{
        		return gcd(valueTwo, valueOne%valueTwo);
        	}
        }
}

/*package whatever //do not write package name here */

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

public class Codeforce {
	public static void main (String[] args) {
	    FastReader fr = new FastReader();
	    int n = fr.nextInt(), k = fr.nextInt(), cnt = 0;
	    long ans = n;
	    while(n%10 == 0) {
	        n/=10;
	        cnt++;
	    }
	    if(k == 0 || cnt >= k) {
	        System.out.println(ans);
	    }else{
	       while(cnt != k) {
	           long z = removeZero(ans);
	           if(z % 5 == 0) {
	               ans *= 2;
	               cnt++;
	           }else if(z %2 == 0) {
	               ans *= 5;
	               cnt++;
	           }else{
	               ans *= 10;
	               cnt++;
	           }
	       }
	       System.out.println(ans);
	    }
	}
	public static long removeZero(long y) {
	    while(y%10 == 0) {
	        y/=10;
	    }
	    return y;
	}
}
class FastReader {

    BufferedReader bf;
    StringTokenizer st;

    public FastReader() {
        bf = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(bf.readLine());
            } catch (Exception e) {
                System.out.println(e);
            }
        }
        return st.nextToken();
    }

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

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

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

    String nextLine() {
        String str = "";
        try {
            str = bf.readLine();
        } catch (Exception e) {
            System.out.println(e);
        }
        return str;
    }
}

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

public class Main {
    static class Reader {
        BufferedReader in;

        Reader() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
        }

        Reader(String name) throws IOException {
            in = new BufferedReader(new FileReader(name));
        }

        StringTokenizer tokin = new StringTokenizer("");

        void updtokin() throws IOException {
            if (!tokin.hasMoreTokens()) {
                String a = in.readLine();
                if (a != null) {
                    tokin = new StringTokenizer(a);
                }
            }
        }

        String next() throws IOException {
            updtokin();
            return tokin.nextToken();
        }

        int nextInt() throws IOException {
            updtokin();
            return Integer.parseInt(tokin.nextToken());
        }
    }

    public static void main(String args[]) throws IOException {
        Reader in = new Reader();
        long n = in.nextInt();
        long k = in.nextInt();
        long n1 = n;
        long pow5 = 0;
        long pow2 = 0;
        while(n1%2 == 0){
            pow2++;
            n1 /= 2;
        }
        while(n1%5 == 0){
            pow5++;
            n1 /= 5;
        }
        if(pow5 > pow2){
            for (k = k;  pow2 < pow5 && pow2 < k; pow2++) {
                n*=2;
            }
        } else {
            for (k = k;  pow5 < pow2 && pow5 < k; pow5++) {
                n*=5;
            }
        }
        for (k = k; pow2 < k; k--) {
            n*=10;
        }
        System.out.println(n);
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.util.regex.*;

public class Main {

    static Scanner input = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static Reader fastInput = new Reader();

    public static void main(String[] args) throws IOException {
        int n = input.nextInt();
        int k = input.nextInt();
        System.out.println(lcm(n, (long) Math.pow(10, k)));
    }

    static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    static class Reader {

        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null) {
                return;
            }
            din.close();
        }
    }
}

import java.io.*;

/**
 *  Created by egor1n
 */

public class Main {

    public static void main(String[] args) throws IOException {
        //long startTime = System.currentTimeMillis();
        Main.run();
        //System.out.println("Время выполнения: " + (System.currentTimeMillis() - startTime) + " мс");
    }

    public static long gcd(long a, int b) {
        while (b != 0) {
            long tmp = a % b;
            a = b;
            b = (int) tmp;
        }
        return a;
    }

    public static long gcm(long a, int b) {
        return a * b / gcd(a, b);
    }

    public static void run() throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] line = reader.readLine().split(" ");
        long n = Long.parseLong(line[0]);
        int k = Integer.parseInt(line[1]);
        System.out.println(gcm(n, (int) Math.pow(10, k)));
    }
}

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

public class Main {

	public static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public char nextChar() {
			return next().charAt(0);
		}

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

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

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

		public int[] nextIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			return arr;
		}

		public Integer[] nextIntegerArr(int n) {
			Integer[] arr = new Integer[n];
			for (int i = 0; i < n; i++) {
				arr[i] = new Integer(this.nextInt());
			}
			return arr;
		}

		public int[][] next2DIntArr(int n, int m) {
			int[][] arr = new int[n][m];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < m; j++) {
					arr[i][j] = this.nextInt();
				}
			}
			return arr;
		}

		public int[] nextSortedIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			Arrays.sort(arr);
			return arr;
		}

		public long[] nextLongArr(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextLong();
			}
			return arr;
		}

		public char[] nextCharArr(int n) {
			char[] arr = new char[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextChar();
			}
			return arr;
		}
	}

	public static InputReader scn = new InputReader();
	public static PrintWriter out = new PrintWriter(System.out);

	public static ArrayList<Integer>[] list;

	public static void main(String[] args) {
		// InputStream inputStream = System.in; // Useful when taking input other than
		// console eg file handling // check ctor of inputReader

		int n = scn.nextInt(), k = scn.nextInt();
		int t = 0, f = 0, nn = n;
		while(n % 2 == 0) {
			t++;
			n /= 2;
			if(t == k) {
				break;
			}
		}
		while(n % 5 == 0) {
			f++;
			n /= 5;
			if(f == k) {
				break;
			}
		}

		long ans = n * (long)Math.pow(10, k);

		ans = Math.max(ans, nn);
		System.out.println(ans % nn == 0 ? ans : 0 / 0);
		out.close();
	}
}

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

public class C
{

    Reader in;
    PrintWriter out;
    int i = 0, j = 0;
    void solve()
    {

        //START//
        long n = in.nextLong();
        int k = in.nextInt();
        int fives = 0, twos = 0;
        if (k == 0)
        {
            out.println(n);
            return;
        }
        int zeros = 0;
        while (zeros < k)
        {
            if (n % 10 == 0)
            {
                n /= 10;
                zeros++;
            }
            else
            {
                if (n % 5 == 0)
                {
                    n /= 5;
                    zeros++;
                }
                else if (n % 2 == 0)
                {
                    n /= 2;
                    zeros++;
                }
                else
                {
                    zeros++;
                }
            }
        }
        out.print(n);
        for (i = 0; i < zeros; i++)
            out.print("0");
        out.println();

        //END

    }
    void runIO()
    {
        in = new Reader();
        out = new PrintWriter(System.out, false);
        solve();
        out.close();
    }

    public static void main(String[] args)
    {
        new C().runIO();
    }

    // input/output
    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);

            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public final String next()
        {
            int c = read();
            while (isSpaceChar(c))
            {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do
            {
                res.append((char) c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

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

        public int nextInt()
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong()
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble()
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (c == '.')
                while ((c = read()) >= '0' && c <= '9')
                    ret += (c - '0') / (div *= 10);
            if (neg)
                return -ret;
            return ret;
        }

        public int[] readIntArray(int size)
        {
            int[] arr = new int[size];
            for (int i = 0; i < size; i++)
                arr[i] = nextInt();
            return arr;
        }

        public long[] readLongArray(int size)
        {
            long[] arr = new long[size];
            for (int i = 0; i < size; i++)
                arr[i] = nextInt();
            return arr;
        }

        private void fillBuffer()
        {
            try
            {
                bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            }
            catch (IOException e)
            {

            }

            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read()
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
    }
}

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

public class Main {
    int mod = (int)1e9+7;

    void solve(BufferedReader br, PrintWriter out) throws IOException{
        String[] s = br.readLine().trim().split(" ");
        long n = Integer.parseInt(s[0]);
        int k = Integer.parseInt(s[1]);
        if(k==0) {
            out.println(n);
            return;
        }
        int a = 0, b=0;
        long x = n;
        while(x%2==0) {
            a++;
            x/=2;
        }
        while(x%5==0) {
            b++;
            x/=5;
        }
        int c = Math.min(a, b);
        c = k - c;
        if(c<0) {
            out.println(n);
            return;
        }
        n *= (long)Math.pow(2, k-a<0?0:k-a);
        n *= (long)Math.pow(5, k-b<0?0:k-b);
        out.println(n);
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;//Integer.parseInt(br.readLine().trim());
        while(t-->0) {
            new Main().solve(br, out);
        }
        br.close();
        out.close();
    }

}

import javafx.util.*;
import java.util.*;
import java.io.*;
import java.math.*;

public class Test5 {

    Random rnd = new Random();
    PrintWriter pw = new PrintWriter(System.out);
    static int[] n;
    int p=0;

    void run(){
        int a = ni(), k = ni(), d=k, p=k, o=1;
        ArrayList<Integer> l = f(a);
        String t = "";
        for(int q=0; q<k; q++) t+="0";
        for(int u : l){
            if(u==2 && d>0) d--;
            else if(u==5 && p>0) p--;
            else o*=u;
        }
        pw.print(o+t);
        pw.flush();
    }

    static ArrayList<Integer> f(int a){
        ArrayList<Integer> l = new ArrayList<>();
        for(int q=2; q*q<=a && q<4; q++) if(a%q<1) for(; a%q<1;) {a/=q; l.add(q);}
        for(int d=6, i=a; (d-1)*(d-1)<=i; d+=6){
            if(a%(d-1)<1)for(; a%(d-1)<1; ) {a/=(d-1); l.add(d-1);}
            if(a%(d+1)<1)for(; a%(d+1)<1; ) {a/=(d+1); l.add(d+1);}
        }
        if(a>1) l.add(a);
        return l;
    }

    static class PyraSort {

        private static int heapSize;

        public static void sort(int[] a) {
            buildHeap(a);
            while (heapSize > 1) {
                swap(a, 0, heapSize - 1);
                heapSize--;
                heapify(a, 0);
            }
        }

        private static void buildHeap(int[] a) {
            heapSize = a.length;
            for (int i = a.length / 2; i >= 0; i--) {
                heapify(a, i);
            }
        }

        private static void heapify(int[] a, int i) {
            int l = 2 * i + 2;
            int r = 2 * i + 1;
            int largest = i;
            if (l < heapSize && a[i] < a[l]) {
                largest = l;
            }
            if (r < heapSize && a[largest] < a[r]) {
                largest = r;
            }
            if (i != largest) {
                swap(a, i, largest);
                heapify(a, largest);
            }
        }

        private static void swap(int[] a, int i, int j) {
            a[i] ^= a[j] ^= a[i];
            a[j] ^= a[i];
            n[i] ^= n[j] ^= n[i];
            n[j] ^= n[i];
        }
    }

    public static void main(String[] args) {
        new Test5().run();
    }

    InputStream is = System.in;
    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte() {
        if (lenbuf == -1) throw new InputMismatchException();
        if (ptrbuf >= lenbuf) {
            ptrbuf = 0;
            try {
                lenbuf = is.read(inbuf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (lenbuf <= 0) return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) {
        return !(c >= 33 && c <= 126);
    }

    private int skip() {
        int b;
        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
        return b;
    }

    private double nd() {
        return Double.parseDouble(ns());
    }

    private char nc() {
        return (char) skip();
    }

    private String nline(){
        int b = readByte();
        StringBuilder sb = new StringBuilder();
        while (b!=10) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private String ns() {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while (!(isSpaceChar(b))) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n) {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while (p < n && !(isSpaceChar(b))) {
            buf[p++] = (char) b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private char[][] nm(int n, int m) {
        char[][] map = new char[n][];
        for (int i = 0; i < n; i++) map[i] = ns(m);
        return map;
    }

    private int[] na(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = ni();
        return a;
    }

    private int ni() {
        int num = 0, b;
        boolean minus = false;
        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        while (true) {
            if (b >= '0' && b <= '9') {
                num = num * 10 + (b - '0');
            } else {
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    private long nl() {
        long num = 0;
        int b;
        boolean minus = false;
        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        while (true) {
            if (b >= '0' && b <= '9') {
                num = num * 10 + (b - '0');
            } else {
                return minus ? -num : num;
            }
            b = readByte();
        }
    }
}

import java.util.*;

public class Main{
    public static void main(String[] v) {
        Scanner s = new Scanner(System.in);
        long n = s.nextInt(), k = (long)Math.pow(10,s.nextInt()), c=n, d=k;
        while(k!=0) {
            k^=n%=k;
            k^=n^=k;
        }
        System.out.print(c*d/n);
    }
}

import java.util.Scanner;
import java.util.StringTokenizer;

public class Round434krounding {
	public static void main(String[] args) {
		Scanner kboard = new Scanner(System.in);

		StringTokenizer token = new StringTokenizer(kboard.nextLine());

		long n = Long.parseLong(token.nextToken());
		int k = Integer.parseInt(token.nextToken());

		long orig = n;

		int fives = 0, twos = 0;
		while (n % 2 == 0) {
			twos += 1;
			n /= 2;
		}
		while (n % 5 == 0) {
			fives += 1;
			n /= 5;
		}

		//System.out.println(fives + " " + twos);

		long ans = 1;
		for (int i = 0; i < k - fives; i++) {
			ans *= 5;
		}
		for (int i = 0; i < k - twos; i++) {
			ans *= 2;
		}

		System.out.println(ans * orig);
	}
}

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class KRounding implements Closeable {

    private InputReader in = new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);

    public void solve() {
        long n = in.ni(), k = in.ni();
        long x = 1L;
        for (int i = 0; i < k; i++) x *= 10;
        out.println(lcm(x, n));
    }

    private long lcm(long a, long b) {
        long gcd = gcd(a, b);
        return (a * b) / gcd;
    }

    private long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    @Override
    public void close() throws IOException {
        in.close();
        out.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int ni() {
            return Integer.parseInt(next());
        }

        public long nl() {
            return Long.parseLong(next());
        }

        public void close() throws IOException {
            reader.close();
        }
    }

    public static void main(String[] args) throws IOException {
        try (KRounding instance = new KRounding()) {
            instance.solve();
        }
    }
}

import java.awt.Dimension;
import java.io.*;
import java.util.*;

public class Sum
{

    public static void main(String[] args)
    {

        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long n=in.nextInt();
        long k=in.nextInt();
        out.println(lcm(n,(int)(Math.pow(10, k))));
        in.close();
        out.flush();
      out.close();

}
    static long gcd(long a, long b)
    {
    	while (b != 0)
    	{
    		long tmp = a % b;
    		a = b;
    		b = tmp;
    	}
    	return a;
    }
    static long lcm(long a, long b)
    {
    	return a / gcd(a, b) * b;
    }

}

import java.util.*;
public class A863
{

public static void main(String[] a)
{
    Scanner x=new Scanner(System.in);
   long n=x.nextLong();
   long k=x.nextLong();
   long temp=1;
   for(long i=1;i<=k;i++)
   {
       temp*=10;
   }
   System.out.println(n*temp/gcd(temp,n));

}
static long gcd(long a, long b)
{
    if (b==0) {
        return a;
    }
    else
    return gcd(b,a%b);
}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
	public static void main(String args[]){

		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n =in.nextInt();
		int k = in.nextInt();
		for(int i=0;i<k;i++){
			if(n%5==0){
				n/=5;
			}
			if(n%2==0){
				n/=2;
			}
		}
		out.print(n);
		for(int i=0;i<k;i++){
			out.print(0);
		}
		out.close();

	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

	public static void main(String[] args) throws NumberFormatException, IOException {
		Scanner sc = new Scanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt(), k = sc.nextInt();
		long ans = 1;
		while(k-->0)
			ans *= 10;
		out.println(lcm(ans, n));
		out.flush();
		out.close();
	}
	static long lcm(long a, long b){
		return a*(b/gcd(a,b));
	}
	static long gcd(long a, long b){
		return b == 0?a:gcd(b, a%b);
	}
	static class Scanner {
		BufferedReader bf;
		StringTokenizer st;

		public Scanner() {
			bf = new BufferedReader(new InputStreamReader(System.in));
		}

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

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

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

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

import java.awt.*;
import java.lang.*;
import java.io.*;
import java.util.*;

public class Main {
    public class Point {
        long x, y;

        Point(long x, long y) {
            this.x = x;
            this.y = y;
        }

        Point(Point a, Point b) {
            x = b.x - a.x;
            y = b.y - a.y;
        }

        public long Len() {
            return x * x + y * y;
        }

        public double Len_d() {
            return Math.sqrt(x * x + y * y);
        }

    }

    public class Line {
        long A, B, C;

        public Line(Point first, Point second) {
            A = first.y - second.y;
            B = second.x - first.x;
            C = first.x * second.y - second.x * first.y;
        }

        public long sign(Point p) {
            long res = A * p.x + B * p.y + C;
            if (res > 0) {
                return 1;
            } else if (res == 0) {
                return 0;
            } else {
                return -1;
            }

        }
    }

    public void solve() throws IOException {
        int n = nextInt(), k = nextInt();
        long m = n;
        int cnt2 = 0, cnt5 = 0;
        while(n % 2 == 0){
            n /= 2;
            cnt2++;
        }
        while(n % 5 == 0){
            n /= 5;
            cnt5++;
        }
        long res = 1;
        while(cnt2 < k){
            res *= 2;
            cnt2++;
        }
        while(cnt5 < k){
            res *= 5;
            cnt5++;
        }
        res *= m;
        out.print(res);
    }

    BufferedReader br;
    StringTokenizer sc;
    PrintWriter out;

    public static void main(String[] args) throws IOException {
        Locale.setDefault(Locale.US);
        new Main().run();
    }

    void run() throws IOException {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    String nextToken() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return sc.nextToken();
    }

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

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

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

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextInt();
            long temp = n;
            int n2 = 0, n5 = 0;
            while (n % 2 == 0) {
                n /= 2;
                n2++;
            }
            while (n % 5 == 0) {
                n /= 5;
                n5++;
            }
            int k = in.nextInt();
            int rem2 = k - n2, rem5 = k - n5;
            while (rem2 > 0) {
                temp *= 2;
                rem2--;
            }
            while (rem5 > 0) {
                temp *= 5;
                rem5--;
            }
            out.print(temp);
        }

    }

    static class InputReader {
        private int lenbuf = 0;
        private int ptrbuf = 0;
        private InputStream in;
        private byte[] inbuf = new byte[1024];

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

        private int readByte() {
            if (lenbuf == -1) throw new InputMismatchException();
            if (ptrbuf >= lenbuf) {
                ptrbuf = 0;
                try {
                    lenbuf = in.read(inbuf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (lenbuf <= 0) return -1;
            }
            return inbuf[ptrbuf++];
        }

        public int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

    }
}

import java.util.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;

public class Main
{

  public static void main(String[] args) throws Exception
  {
    long startTime = System.nanoTime();
    long n=in.nextInt();
    int k=in.nextInt();
    int two=count_primes(n,2);
    int target_two=k;
    int target_five=k;
    int five=count_primes(n,5);
    if(k<=Math.min(two,five))
    {
        out.println(n);
    }
    else
    {
        if(target_two>=two)
        {
            target_two-=two;
        }
        else
        {
            target_two=0;
        }
        if(target_five>=five)
        {
            target_five-=five;
        }
        else
        {
            target_five=0;
        }
        out.println((long)(n*Math.pow(2,target_two)*Math.pow(5,target_five)));
    }
    long endTime = System.nanoTime();
    err.println("Execution Time : +" + (endTime-startTime)/1000000 + " ms");
    exit(0);
  }

static int count_primes(long n,int p)
{
    int count=0;
    while(n>0 && n%p==0)
    {
        count++;
        n/=p;
    }
    return count;
}

  static class InputReader
  {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

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

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

    static void exit(int a)
    {
      out.close();
      err.close();
      System.exit(a);
    }

    static InputStream inputStream = System.in;
    static OutputStream outputStream = System.out;
    static OutputStream errStream = System.err;
    static InputReader in = new InputReader(inputStream);
    static PrintWriter out = new PrintWriter(outputStream);
    static PrintWriter err = new PrintWriter(errStream);
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

}

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

public class A {
    public static void main(String[] args){
        new A().run();
    }
    public static void run(){
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        int k = in.nextInt();
        int f = 1;
        while(n % Math.pow(10, k) != 0){
            long t = (long)n / f;
            t = t % 10;
            if(t == 5){
                n *= 2;
            } else if(t == 0){
                f *= 10;
            } else if(t % 2 == 0){
                n *= 5;
            } else {
                n *= 10;
            }
        }
        System.out.println(n);
    }
}

import java.util.Scanner;
import java.util.stream.IntStream;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int n = sc.nextInt();
		int k = sc.nextInt();
		System.out.println(solve(n, k));

		sc.close();
	}

	static long solve(int n, int k) {
		int pow10 = IntStream.range(0, k).reduce(1, (result, element) -> result * 10);

		return (long) pow10 / gcd(n, pow10) * n;
	}

	static int gcd(int a, int b) {
		return (b == 0) ? a : gcd(b, a % b);
	}
}

import java.io.*;
import java.util.*;
public class kRounding
{
    static long gcd(long a, long b)
    {
        if(a==0)
            return b;
        return gcd(b%a,a);
    }
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        long n=sc.nextLong();
        long k=sc.nextLong();
        long z=(long)Math.pow(10,k);
        long p=z*n;
        long lcm=p/gcd(n,z);
        System.out.println(lcm);
    }
}

import java.util.*;
public class kround {
static long gcd(long a, long ten)
{
	if(a==0)
		return ten;
	return gcd(ten%a,a);

}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		long n=s.nextInt();
		long k=s.nextInt();
		long ten= (long)Math.pow(10, k);

		long lcm=n*ten/gcd(n,ten);
		System.out.println(lcm);
			}

}

/**
 * DA-IICT
 * Author : PARTH PATEL
 */
import java.io.*;
import java.math.*;
import java.util.*;

import static java.util.Arrays.fill;
import static java.lang.Math.*;
import static java.util.Arrays.sort;
import static java.util.Collections.sort;

public class TaskA
{

	public static int mod = 1000000007;
	static FasterScanner in = new FasterScanner();
	static PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args)
	{

		long[] power=new long[9];
		power[0]=1;
		for(int i=1;i<9;i++)
		{
			power[i]=10*power[i-1];
		}
		long n=in.nextInt();
		int k=in.nextInt();
		long tenpower=power[k];
		long tempn=n;
		while(tenpower%5==0 && tempn%5==0)
		{
			tenpower/=5;
			tempn/=5;
		}
		while(tenpower%2==0 && tempn%2==0)
		{
			tenpower/=2;
			tempn/=2;
		}
		long answer=tempn*power[k];
		out.println(answer);
		out.close();

	}

	public static long pow(long x, long n, long mod)
	{
		long res = 1;
		for (long p = x; n > 0; n >>= 1, p = (p * p) % mod)
		{
			if ((n & 1) != 0)
			{
				res = (res * p % mod);
			}
		}
		return res;
	}

	public static long gcd(long n1, long n2)
	{
		long r;
		while (n2 != 0)
		{
			r = n1 % n2;
			n1 = n2;
			n2 = r;
		}
		return n1;
	}

	static class FasterScanner
	{
		private byte[] buf = new byte[1024];
		private int curChar;
		private int snumChars;

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

		public String nextLine()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString()
		{
			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 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 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 int[] nextIntArray(int n)
		{
			int[] arr = new int[n];
			for (int i = 0; i < n; i++)
			{
				arr[i] = nextInt();
			}
			return arr;
		}

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

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

		private boolean isEndOfLine(int c)
		{
			return c == '\n' || c == '\r' || c == -1;
		}
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int N = in.nextInt();
            int K = in.nextInt();

            out.println(LCM(N, ten(K)));
        }

        private long LCM(long A, long B) {
            return A * B / gcd(A, B);
        }

        private long gcd(long A, long B) {
            if (B == 0) return A;
            return gcd(B, A % B);
        }

        private int ten(int pow) {
            int ans = 1;
            for (int i = 0; i < pow; i++) {
                ans *= 10;
            }
            return ans;
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }
}

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

	public class A861
	{
		public static void main(String[] args)
		{
			InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);

			long n = in.nextLong();
			long k = in.nextLong();
			long p = (long)Math.pow(10, k);

			System.out.println(LCM(n,p));

			pw.flush();
			pw.close();
		}

		public static long GCD(long a,long b)
		{
			if(b==0)
				return a;
			else
				return GCD(b,a%b);
		}

		public static long LCM(long a,long b)
		{
			return (a*b)/GCD(a,b);
		}

		static class InputReader
		{

			private final InputStream stream;
			private final byte[] buf = new byte[8192];
			private int curChar, snumChars;
			private SpaceCharFilter filter;

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

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

			public int nextInt()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
			    {
					sgn = -1;
					c = snext();
				}
				int res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

			public long nextLong()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
				{
					sgn = -1;
					c = snext();
				}
				long res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

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

			public String readString()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isSpaceChar(c));
				return res.toString();
			}

			public String nextLine()
			{
				int c = snext();
				while (isSpaceChar(c))
					c = snext();
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isEndOfLine(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;
			}

			private boolean isEndOfLine(int c)
			{
				return c == '\n' || c == '\r' || c == -1;
			}

			public interface SpaceCharFilter
		    {
				public boolean isSpaceChar(int ch);
			}
		}
	}

/**
 * Created by Aminul on 2/27/2018.
 */

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

public class CF858A {
    public static void main(String[] args)throws Exception {
        FastReader in = new FastReader(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        int n = in.nextInt(), k = (int)Math.pow(10, in.nextInt());
        pw.println(lcm(n, k));

        pw.close();
    }

    static long gcd(long p, long q) {
        if (q == 0) return p;
        else return gcd(q, p % q);
    }

    static long lcm(long p, long q) {
        long g = gcd(p, q);
        p /= g;
        return p*q;
    }

    static void debug(Object...obj) {
        System.err.println(Arrays.deepToString(obj));
    }

    static class FastReader {
        InputStream is;
        private byte[] inbuf = new byte[1024];
        private int lenbuf = 0, ptrbuf = 0;
        static final int ints[] = new int[128];

        public FastReader(InputStream is){
            for(int i='0';i<='9';i++) ints[i]=i-'0';
            this.is = is;
        }

        public int readByte(){
            if(lenbuf == -1)throw new InputMismatchException();
            if(ptrbuf >= lenbuf){
                ptrbuf = 0;
                try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
                if(lenbuf <= 0)return -1;
            }
            return inbuf[ptrbuf++];
        }

        public boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }
        public int skip() {
            int b;
            while((b = readByte()) != -1 && isSpaceChar(b));
            return b;
        }

        public String next(){
            int b = skip();
            StringBuilder sb = new StringBuilder();
            while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        public int nextInt(){
            int num = 0, b;
            boolean minus = false;
            while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
            if(b == '-'){
                minus = true;
                b = readByte();
            }

            while(true){
                if(b >= '0' && b <= '9'){
                    num = (num<<3) + (num<<1) + ints[b];
                }else{
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public long nextLong() {
            long num = 0;
            int b;
            boolean minus = false;
            while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
            if(b == '-'){
                minus = true;
                b = readByte();
            }

            while(true){
                if(b >= '0' && b <= '9'){
                    num = (num<<3) + (num<<1) + ints[b];
                }else{
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
       /* public char nextChar() {
            return (char)skip();
        }*/

        public char[] next(int n){
            char[] buf = new char[n];
            int b = skip(), p = 0;
            while(p < n && !(isSpaceChar(b))){
                buf[p++] = (char)b;
                b = readByte();
            }
            return n == p ? buf : Arrays.copyOf(buf, p);
        }

        /*private char buff[] = new char[1005];
        public char[] nextCharArray(){
            int b = skip(), p = 0;
            while(!(isSpaceChar(b))){
                buff[p++] = (char)b;
                b = readByte();
            }
            return Arrays.copyOf(buff, p);
        }*/
    }
}

import java.util.*;

public class Codeforces {

    public static int count(String p){
		int counts=0;
		for(int i=p.length()-1;i>=0;i--){

			if(p.charAt(i)!='0')
				return counts;
			else
				counts++;

		}

		return counts;
	}

	public static void main(String[] args) {

		Scanner sc=new Scanner(System.in);

		long n=sc.nextLong();
		int k=sc.nextInt();

		String p=""+n;

		if(count(p)>=k)
			System.out.println(n);
		else{
			//System.out.println("not term at first");

			int last=Integer.parseInt(""+p.charAt(p.length()-1));

			if(last==1 || last==3 || last==7 || last==9){

				for(int i=1;i<=k;i++)
					p=p+"0";

				System.out.println(p);

			}
			else{

				while(count(p)<k){
					//System.out.println("count was "+count(p));
					int index=-1;
					for(int i=p.length()-1;i>=0;i--){

						if(p.charAt(i)!='0'){
							index=i;
							break;
						}

					}

					last=Integer.parseInt(""+p.charAt(index));
					//System.out.println("last is "+last);
					if(last==2 || last==4 || last==6 || last==8){
						n=n*5;
						p=""+n;
					}
					else if(last==5){
						n=n*2;
						p=""+n;
					}
					else if(last==1 || last==3 || last==7 || last==9){
						int rem=k-count(p);
						for(int i=1;i<=rem;i++)
							p=p+"0";

						break;

					}

				}

				System.out.println(p);

			}

		}

	}
}

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class Main {

	private static final String NO = "NO";
	private static final String YES = "YES";
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	private static final long MOD = 998244353L;
	private static final int MAX = 100000;

	void solve() {
		long N = ni();
		int k = ni();
		int p2 = get(N, 2);
		int p5 = get(N, 5);
//		tr(p2, p5);
		N = up(N, 2, k - p2);
		N = up(N, 5, k - p5);
		out.println(N);
	}

	private long up(long n, int b, int p) {
		while (p-- > 0)
			n *= b;
		return n;
	}

	private int get(long n, int b) {
		int ret = 0;
		while (n % b == 0) {
			n /= b;
			ret++;
		}
		return ret;
	}

	long power(long a, long b) {
		long x = 1, y = a;
		while (b > 0) {
			if (b % 2 != 0) {
				x = (x * y) % MOD;
			}
			y = (y * y) % MOD;
			b /= 2;
		}
		return x % MOD;
	}

	private long gcd(long a, long b) {
		while (a != 0) {
			long tmp = b % a;
			b = a;
			a = tmp;
		}
		return b;
	}

	void run() throws Exception {
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		if (!INPUT.isEmpty())
			tr(System.currentTimeMillis() - s + "ms");
	}

	public static void main(String[] args) throws Exception {
		new Main().run();
	}

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;
	private boolean vis[];

	private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = is.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) {
		return !(c >= 33 && c <= 126);
	}

	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	private double nd() {
		return Double.parseDouble(ns());
	}

	private char nc() {
		return (char) skip();
	}

	private String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != '
									// ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n) {
			if (!(isSpaceChar(b)))
				buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m) {
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private Integer[] na2(int n) {
		Integer[] a = new Integer[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private int[][] na(int n, int m) {
		int[][] a = new int[n][];
		for (int i = 0; i < n; i++)
			a[i] = na(m);
		return a;
	}

	private Integer[][] na2(int n, int m) {
		Integer[][] a = new Integer[n][];
		for (int i = 0; i < n; i++)
			a[i] = na2(m);
		return a;
	}

	private int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private static void tr(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}
}

import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.System.*;
public class A
{
public static void main (String args[]) throws Exception
{
	 Scanner sc=new Scanner(in);
	 long n=sc.nextLong();
	 long k=sc.nextLong();
	 long x=(long)(Math.pow(10,k));
	 long ans=GCD(x,n);
	 ans=(n*x)/ans;
	 out.println(ans);

 }
 public static long GCD(long a, long b) {
    if (b==0) return a;
    return GCD(b,a%b);
}
}

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

/**
 *
 * @author ramil.agger
 *
 */

public class Main {

    final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    long GCD(long u, long v) {
        while ( v != 0) {
            long r = u % v;
            u = v;
            v = r;
        }
        return u;
    }

    void solve() {
        int k = nextInt();
        int n = nextInt();
        long a = 1;
        while (n > 0) {
            n--;
            a *= 10;
        }
        long gcd = GCD(k,a);
        long ans = (a * k) / gcd;
        pw.println(ans);
    }

    public static void main(String[] args) {
        new Main();
    }

    void run() throws IOException {
        start = System.currentTimeMillis();
        solve();
        if (!ONLINE_JUDGE)
            System.err.println(System.currentTimeMillis() - start + " ms");
        br.close();
        pw.close();
    }

    Main() {
        try {
            br = (ONLINE_JUDGE)
                    ? new BufferedReader(new InputStreamReader(System.in))
                    : new BufferedReader(new FileReader("in.txt"));
            pw = (ONLINE_JUDGE)
                    ? new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)))
                    : new PrintWriter(new BufferedWriter(new FileWriter("out.txt")));
            this.run();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

    boolean hasNext() {
        if (st != null && st.hasMoreTokens()) return true;
        try {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    String next() {
        if (hasNext())
            return st.nextToken();
        return null;
    }

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

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

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

    BigInteger nextBigInteger() {
        return new BigInteger(next());
    }

    String nextLine() {
        if(hasNext()) return st.nextToken("\n");
        else return null;
    }

    int[] nextArray(int n){
        int[] temp = new int[n];
        for (int i = 0; i < n; i++)
            temp[i] = nextInt();
        return temp;
    }

    long[] nextLArray(int n) {
        long[] temp = new long[n];
        for (int i = 0; i < n; i++)
            temp[i] = nextInt();
        return temp;
    }

    long start;
    final BufferedReader br;
    final PrintWriter pw;
    StringTokenizer st;
}

import java.util.Scanner;

public class Main {

    public static String make(long k){
        String s="";
        for (int i=0;i<k;i++){
            s+='0';
        }
        return s;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        long k = sc.nextInt();
        long two = 0;
        long five = 0;
        long a = n;
        while (a % 5 == 0) {
            five++;
            a /= 5;
        }
        while (a % 2 == 0) {
            two++;
            a /= 2;
        }
        long ans = n;
        String s=make(k);
        while(!String.valueOf(ans).endsWith(s)){
            if(two<five){
                ans*=2;
                two++;
            }else{
                if(two>five){
                    ans*=5;
                    five++;
                }else{
                    if(String.valueOf(ans).charAt(String.valueOf(ans).length()-1)=='0'||String.valueOf(ans).charAt(String.valueOf(ans).length()-1)=='5'){
                        ans*=2;
                        two++;
                    }else{
                        ans*=5;
                        five++;
                    }
                }
            }
        }
        System.out.println(ans);
    }
}

import java.util.Scanner;

public class TaskA {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        TaskA inst = new TaskA();
        long n = in.nextLong(), k = in.nextLong();
        System.out.println(
                (long)(n * Math.pow(10, k) / inst.gcd(n, (long) Math.pow(10, k)))
        );
    }
    private long gcd(long a, long b){
        return b == 0 ? a : gcd(b, a % b);
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
//package codeforces;
import java.math.BigInteger;
import java.util.*;
/**
 *
 * @author Ashraf
 */
public class DVA {
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        long n=in.nextLong();
        int k=in.nextInt();
        long sum=(long)Math.pow(10, k);
        BigInteger b1 = new BigInteger(""+n); // there's a better way to do this. I forget.
        BigInteger b2 = new BigInteger(""+sum);
        BigInteger gcd = b1.gcd(b2);
        long x=gcd.intValue();
        //System.out.println(x);
        System.out.println((n*sum)/x);
    }
}

//package CF_434;

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

public class A {
	public static void main(String[] args) throws Exception{ new A(new Reader()); }
	public A(Reader rr) throws IOException{
		long n=rr.nl(), k=rr.nl();
		boolean ok=true;
		for(int i=1; i<=k; i++){
			if(n%(Math.pow(10, i))!=0) ok=false;
		}
		if(!ok){
			for(int i=1; i<=k; i++){
				long lastDig=(n%(int)Math.pow(10, i))/(int)Math.pow(10, i-1);
				if(lastDig==0) continue;
				if(lastDig==1||lastDig==3||lastDig==7||lastDig==9){
					break;
				}else{
					if(lastDig==2||lastDig==4||lastDig==6||lastDig==8) n*=5;
					else if(lastDig==5) n*=2;
				}
			}
			for(int i=1; i<=k; i++){
				if(n%(Math.pow(10, i))!=0) n*=10;
			}
		}
		System.out.println(n);
	}
	static class Reader{
		private DataInputStream din;
		private byte[] buffer=new byte[1024];
		private int bufP, bytR;
		public Reader() throws IOException{
			din=new DataInputStream(System.in);
			bufP=bytR=0;
		}
		public Reader(String file) throws IOException{
			din=new DataInputStream(new FileInputStream(file));
			bufP=bytR=0;
		}
		private String rl() throws IOException{
			byte[] buf=new byte[1024];
			int cnt=0, c;
			while((c=read())!=-1){
				if(c=='\n') break;
				buf[cnt++]=(byte)c;
			}
			return new String(buf, 0, cnt);
		}
		private int ni() throws IOException{
			int num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private long nl() throws IOException{
			long num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private double nd() throws IOException{ return Double.parseDouble(ns()); }
		private char nc() throws IOException{ return (char)next(); }
		private String ns() throws IOException{
			int c=next();
			StringBuilder sb=new StringBuilder();
			while(!(isChar(c))){
				sb.appendCodePoint(c);
				c=read();
			}
			return sb.toString();
		}
		private char[] ns(int n) throws IOException{
			char[] buf=new char[n];
			int c=next(), r=0;
			while(r<n&&!(isChar(c))){
				buf[r++]=(char)c;
				c=next();
			}
			return n==r?buf:Arrays.copyOf(buf, r);
		}
		private char[][] nm(int n, int m) throws IOException{
			char[][] map=new char[n][];
			for(int i=0; i<n; i++) map[i]=ns(m);
			return map;
		}
		private int[] na(int n) throws IOException{
			int[] a=new int[n];
			for(int i=0; i<n; i++) a[i]=ni();
			return a;
		}
		private boolean isChar(int c) throws IOException{ return !(c>=33&&c<=126); }
		private int next() throws IOException{ int c; while((c=read())!=-1&&isChar(c)); return c; }
		private byte read() throws IOException{
			if(bufP==bytR){
				bytR=din.read(buffer, bufP=0, 1024);
				if(bytR==-1) buffer[0]=-1;
			}
			return buffer[bufP++];
		}
		public void close() throws IOException{
			if(din==null) return;
			din.close();
		}
	}
}

import java.util.Scanner;

public class Problem858A {

	private static Scanner scanner;

	public static void main(String[] args) {
		scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int k = scanner.nextInt();
		long ans = n;

		while (k != 0) {
			int lastDigit = n % 10;
			if (lastDigit == 0) {
				n /= 10;
			} else if (lastDigit == 5) {
				n /= 5;
				ans *= 2;
			} else if (lastDigit % 2 == 0) {
				n /= 2;
				ans *= 5;
			} else {
				ans *= 10;
			}
			k--;
		}

		System.out.println(ans);
	}
}

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

public class methodThree {

	public static void kRounding()
	{
		long n,k,y,a,b,r=0,x=1;
		long ans;
		Scanner sc=new Scanner(System.in);
		n=sc.nextInt();
		k=sc.nextInt();
		for(int i=0;i<k;i++)
		{
			x=x*10;
		}
		ans=(n*x);
		if(x<n)
		{
			a=x;b=n;
		}
		else
		{
			a=n;b=x;
		}
		if(b%a==0)
		r=a;
		else
		{
			while(b%a!=0)
			{
				r=b%a;
				b=a;
				a=r;
			}
		}
		System.out.println(ans/r);
	}

	public static void main(String[] args) throws IOException {
		kRounding();
	}
}

    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.*;

    public class Main
    {
        static class Reader
        {
            final private int BUFFER_SIZE = 1 << 16;
            private DataInputStream din;
            private byte[] buffer;
            private int bufferPointer, bytesRead;

            public Reader()
            {
                din = new DataInputStream(System.in);
                buffer = new byte[BUFFER_SIZE];
                bufferPointer = bytesRead = 0;
            }

            public Reader(String file_name) throws IOException
            {
                din = new DataInputStream(new FileInputStream(file_name));
                buffer = new byte[BUFFER_SIZE];
                bufferPointer = bytesRead = 0;
            }

            public String readLine() throws IOException
            {
                byte[] buf = new byte[64]; // line length
                int cnt = 0, c;
                while ((c = read()) != -1)
                {
                    if (c == '\n')
                        break;
                    buf[cnt++] = (byte) c;
                }
                return new String(buf, 0, cnt);
            }

            public int nextInt() throws IOException
            {
                int ret = 0;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();
                do
                {
                    ret = ret * 10 + c - '0';
                }  while ((c = read()) >= '0' && c <= '9');

                if (neg)
                    return -ret;
                return ret;
            }

            public long nextLong() throws IOException
            {
                long ret = 0;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();
                do {
                    ret = ret * 10 + c - '0';
                }
                while ((c = read()) >= '0' && c <= '9');
                if (neg)
                    return -ret;
                return ret;
            }

            public double nextDouble() throws IOException
            {
                double ret = 0, div = 1;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();

                do {
                    ret = ret * 10 + c - '0';
                }
                while ((c = read()) >= '0' && c <= '9');

                if (c == '.')
                {
                    while ((c = read()) >= '0' && c <= '9')
                    {
                        ret += (c - '0') / (div *= 10);
                    }
                }

                if (neg)
                    return -ret;
                return ret;
            }

            private void fillBuffer() throws IOException
            {
                bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
                if (bytesRead == -1)
                    buffer[0] = -1;
            }

            private byte read() throws IOException
            {
                if (bufferPointer == bytesRead)
                    fillBuffer();
                return buffer[bufferPointer++];
            }

            public void close() throws IOException
            {
                if (din == null)
                    return;
                din.close();
            }
        }
        public static void main(String[] args) throws IOException {

            Reader s = new Reader();

            long i = s.nextLong();
            int k = s.nextInt();
            long n = i;

            int num5 = 0;
            int num2 = 0;

            while (n % 5 == 0) {
                n /= 5;
                num5++;
            }
            while (n % 2 == 0) {
                n /= 2;
                num2++;
            }
            while (num5 < k) {
                i *= 5;
                num5++;
            }
            while (num2 < k) {
                i *= 2;
                num2++;
            }
            System.out.println(i);

            }
    }

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        long n = in.nextLong();
        int k = in.nextInt();

        for (int i = 0, m = 10; i < k; i++, m *= 10) {
            for (long p = n; n % m != 0; n += p) ;
        }

        out.println(n);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

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

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

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

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

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

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

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // in = new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // out = new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
import java.util.Scanner;

public class k_rounding {
    static long gcd(long x ,long y){
        if(y==0)
            return x;
        return gcd(y,x%y);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        int k = sc.nextInt();
        int i = (int)Math.pow(10,k);
        System.out.println(i*n/gcd(i,n));

    }
}

import java.util.*;

public class test
{
    private static Scanner sc = new Scanner(System.in);
	private static String abc[] = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};

	public static void main(String[] args)
    {
		long n = sc.nextLong();
		long k = sc.nextLong();

		long answer = n;
		for(int i=0;i<k;i++)answer*=10;

		for(int i=0;i<k;i++)
		{
			if(n%2==0)
			{
				n/=2;
				answer/=2;
			}
			if(n%5==0)
			{
				n/=5;
				answer/=5;
			}
		}

		System.out.println(answer);

	}
}

/*
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5  10
6  7
7  9
8  12
9  21
10 19
11 46
12 67
13 69
14 68
15 77
*/

import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.StringTokenizer;

public class A {

	public static void main(String[] args) {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		long n = scan.nextInt(), k = scan.nextInt();
		out.println(lcm((long)Math.pow(10, k), n));
		out.close();
	}

	static long gcd(long a, long b) {return b==0?a:gcd(b, a%b);}
	static long lcm(long a, long b) {return a*b/gcd(a, b);}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

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

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

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

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

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

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

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}

import java.math.BigInteger;
import java.util.Scanner;

public class Krounding1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int k = input.nextInt();
	    long ans = (long)Math.pow(10,k);
	    ans = ans / BigInteger.valueOf(ans).gcd(BigInteger.valueOf(n)).longValue();
	    ans = ans*n;
	    System.out.println(ans);
	}

	private static long gcd(int a, int b){
		if(b==0)return a;
		else
			return gcd(b,a%b);
	}
	private static long lcm(int a, int b){
		return (a*b)/gcd(a,b);
	}

}

import java.util.Scanner;
import java.util.ArrayList;
public class Name8
{

    public static void main(String[]args)
{
    Scanner scan = new Scanner(System.in);
    long n = scan.nextInt();
    long m = n;
    int k = scan.nextInt();
    int d2 = 0;
    int d5 = 0;
    while (n%2==0)
    {
        d2++;
        n/=2;
    }

    while (n%5==0)
    {
        d5++;
        n/=5;
    }

    if (d2 < k)
    {
        m*=Math.pow(2, k-d2);
    }

    if (d5 < k)
    {
        m*=Math.pow(5, k-d5);
    }

    System.out.println(m);
}
}

import java.math.BigInteger;
import java.util.*;
import java.io.*;

public class solution {
    public static void merge(int arr[], int l, int m, int r) {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        int L[] = new int[n1];
        int R[] = new int[n2];

        /*Copy data to temp arrays*/
        for (int i = 0; i < n1; ++i)
            L[i] = arr[l + i];
        for (int j = 0; j < n2; ++j)
            R[j] = arr[m + 1 + j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    public static void sort(int arr[], int l, int r) {
        if (l < r) {
            // Find the middle point
            int m = (l + r) / 2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr, m + 1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        } else return gcd(b, a % b);
    }

    static class pair {
        int x;
        int y;

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

    public static long lcm(long a, long b) {
        long v = a * b;
        long u = gcd(a, b);
        return v / u;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        long n = Long.parseLong(st.nextToken());
        long k = Long.parseLong(st.nextToken());
        long v = (long)Math.pow(10,k);
        long lcm = lcm(n,v);
        System.out.println(lcm);
    }

    static class sort implements Comparator<ArrayList<Integer>> {

        @Override
        public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
            int c = o2.get(1).compareTo(o1.get(1));
            if(c == 0){
                c = o2.get(0).compareTo(o1.get(0));
            }
            return c;
        }

    }
}

import java.util.Scanner;

public class MyPreparation {

    public static void main(String[] args) {
        TaskA Solver = new TaskA();
        Solver.Solve();
    }

    static class TaskA {
        public void Solve() {
            Scanner in = new Scanner(System.in);
            long n = in.nextLong();
            long k = in.nextLong();
            System.out.println(lcm(n, (long) Math.pow(10, k)));
        }
        private long lcm(long a, long b) {
            return ((a * b) / gcd(a, b));
        }
        public long gcd(long a, long b) {
            if (b == 0)
                return a;
            else
                return gcd(b, a % b);
        }
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class First {
    private static final Scanner sc = new Scanner(System.in);
    private static final PrintWriter pw = new PrintWriter(System.out);
    private static StringBuffer ans = new StringBuffer();

    public static void main(String[] args) throws Exception {
        long a = sc.nextLong(), k = sc.nextLong(), b = 1;
        for (long i = 0L; i < k; i++) b *= 10L;
        ans.append((a * b) / gcd(a, b));
        pw.print(ans);
        sc.close();
        pw.close();
    }

    private static long gcd(long a, long b) {
        return b == 0L ? a : gcd(b, a % b);
    }
}

class Scanner {
    private final BufferedReader br;
    private StringTokenizer st;

    public Scanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
        st = new StringTokenizer("");
    }

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

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

    public void close() throws IOException {
        br.close();
    }
}

class PrintWriter {
    private final BufferedOutputStream pw;

    public PrintWriter(OutputStream out) {
        pw = new BufferedOutputStream(out);
    }

    public void print(Object o) throws IOException {
        pw.write(o.toString().trim().getBytes());
        pw.flush();
    }

    public void close() throws IOException {
        pw.close();
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            long INPUT = in.readInt();
            int k = in.readInt();
            int twos = 0;
            int fives = 0;
            long n = INPUT;
            while (n % 2 == 0) {
                twos++;
                n /= 2;
            }
            while (n % 5 == 0) {
                fives++;
                n /= 5;
            }
            int moarFives = Math.max(0, k - fives);
            int moarTwos = Math.max(0, k - twos);
            out.printLine(INPUT * IntegerUtils.power(5, moarFives) * IntegerUtils.power(2, moarTwos));
        }
    }
    static class IntegerUtils {
        public static long power(long base, long exponent) {
            if (exponent == 0) {
                return 1;
            }
            long result = power(base, exponent >> 1);
            result = result * result;
            if ((exponent & 1) != 0) {
                result = result * base;
            }
            return result;
        }
    }
    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

        public void printLine(long i) {
            writer.println(i);
        }
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

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

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
}

import java.util.*;

public class B{
    public static void main(String[] v) {
        Scanner s = new Scanner(System.in);
        long n = s.nextInt(), k = (long)Math.pow(10,s.nextInt()), c=n, d=k;
        while(k!=0) {
            k^=n%=k;
            k^=n^=k;
        }
        System.out.print(c*d/n);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Stack;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        PrintWriter out = new PrintWriter(outputStream);
        InputReader in = new InputReader(inputStream);

        long n=in.nextLong(),k=in.nextLong();
        long f=0,z=0,ans=n;
        while(n%5==0){
            n/=5;
            f++;
        }
        while(n%2==0){
            n/=2;
            z++;
        }
        while(k>0){
            int t=1;
            if(f>0)f--;
            else t*=5;
            if(z>0)z--;
            else t*=2;
            ans*=t;
            k--;
        }
        out.println(ans);
        out.close();
    }

    static class InputReader {

        BufferedReader reader;
        StringTokenizer tokenizer;

        public InputReader(InputStream inputStream) {
            reader = new BufferedReader(new InputStreamReader(inputStream), 32624);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException ex) {
                }
            }
            return tokenizer.nextToken();
        }

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

        private long nextLong() {
            return Long.parseLong(next());
        }

        private double nextDouble() {
            return Double.parseDouble(next());
        }

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

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

        public double[] nextArrayd(int n) {
            double[] a = new double[n];
            for (int i = 0; i < n; i++) {
                a[i] = nextDouble();
            }
            return a;
        }

        private BigInteger nextBigInteger() {
            return new BigInteger(next());
        }

        public void printAr(int[] a) {
            System.out.print("[");
            for (long x : a) {
                System.out.print(x + ",");
            }
            System.out.print("]");
        }
    }

}

import java.util.Scanner;

public class Problem858A {

	private static Scanner scanner;

	public static void main(String[] args) {
		scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int k = scanner.nextInt();
		long ans = n;

		while (k != 0) {
			int lastDigit = n % 10;
			if (lastDigit == 0) {
				n /= 10;
			} else if (lastDigit == 5) {
				n /= 5;
				ans *= 2;
			} else if (lastDigit % 2 == 0) {
				n /= 2;
				ans *= 5;
			} else {
				ans *= 10;
			}
			k--;
		}

		System.out.println(ans);
	}
}

import java.util.*;
public class A861
{
	public static void main(String[] args)
	{
		long n,k,y,a,b,r=0,x=1;
		long ans;
		Scanner sc=new Scanner(System.in);
		n=sc.nextInt();
		k=sc.nextInt();
		for(int i=0;i<k;i++)
		{
			x=x*10;
		}
		ans=(n*x);
		if(x<n)
		{
			a=x;b=n;
		}
		else
		{
			a=n;b=x;
		}
		if(b%a==0)
		r=a;
		else
		{
			while(b%a!=0)
			{
				r=b%a;
				b=a;
				a=r;
			}
		}
		System.out.println(ans/r);
	}
}

//package io.LapTrinh.Hello;

import java.util.Scanner;
import java.lang.*;

public class Heloo {
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long k = in.nextInt();
        long t = 1;
        for (int i =0;i < k;i++){
            t*=10;
        }
        System.out.print(n*t/gcd(t,n));
    }
    public static long gcd(long a, long b){
        while (a != 0 && b!= 0 ){
            if (a >b) a%=b;
            else b%=a;
        } return a+b;
    }
}

//package leto;

import java.io.*;
import java.util.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class techno {
	FastScanner in;
	PrintWriter out;

	static ArrayList<Integer>[] gr, ans;
	static int[]  a, cnt;
	static ArrayList<Integer> del;
	static int maxN = 1000010;
	static int mod = 1000000007;
	static int cons = 200001;

	public static void main(String[] arg) {
		new techno().run();
	}
	public void solve() throws IOException {
	//	Scanner scan = new Scanner(System.in);
		long n = in.nextInt();
		int k = in.nextInt();
		int sum2 = 0;
		int sum5 = 0;
		long t = n;
		while(t % 2 == 0){
			t /= 2;
			sum2++;
		}
		t = n;
		while(t % 5 == 0){
			t /= 5;
			sum5++;
		}
		for(int i = sum2;i<k;i++){
			n *= 2;
		}
		for(int i = sum5;i<k;i++){
			n *= 5;
		}
		out.println(n);
	}

	class Plane implements Comparable<Plane>{
		int i;
		int c;
		public Plane(int i, int c){
			this.i = i;
			this.c = c;
		}
		public int compareTo(Plane a) {
			if(a.c < c){
				return -1;
			}
			if(a.c > c){
				return 1;
			}
			return 0;
		}
	}

	private static int gcd(int a, int b) {
		while ((a != 0) && (b != 0)) {
			if (a < b) {
				int tmp = a;
				a = b;
				b = tmp;
			}
			a %= b;
		}
		return (a + b);
	}

	public void run() {
		try {
			in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
			out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner(BufferedReader bufferedReader) {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

public class Main
{
    public static void main(String[] args)
   	{
       	InputStream inputStream = System.in;
       	OutputStream outputStream = System.out;
       	Reader in = new Reader(inputStream);
       	PrintWriter out = new PrintWriter(outputStream);
       	TaskA solver = new TaskA();
       	solver.solve(1, in, out);
      	out.close();
	}
}
class TaskA
{
    public void solve(int testNumber, Reader in, PrintWriter out)
    {
        long n = Long.parseLong(in.next());
        int k = in.nextInt();
        long temp=n;
        int cnt2=0,cnt5=0,tempk=k;
        while(0<tempk&&temp%2==0)
        {
        	cnt2++;
        	temp/=2;
        	tempk--;
        }
        tempk=k;
        while(0<tempk&&temp%5==0)
        {
        	cnt5++;
        	temp/=5;
        	tempk--;
        }
        for(int i=0;i<k-cnt2;i++)
        {
        	n*=2;
        }
        for(int i=0;i<k-cnt5;i++)
        {
        	n*=5;
        }
        out.println(n);
    }
}

class Reader
{
	public BufferedReader reader;
	public StringTokenizer tokenizer;

	public Reader(InputStream stream)
	{
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		tokenizer = null;
	}

	public String next()
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
		{
			try {
					tokenizer = new StringTokenizer(reader.readLine());
                }
            catch (IOException e)
            {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

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

}

import java.util.*;
public class A863
{

public static void main(String[] a)
{
    Scanner x=new Scanner(System.in);
   long n=x.nextLong();
   long k=x.nextLong();
   long temp=1;
   for(long i=1;i<=k;i++)
   {
       temp*=10;
   }
   System.out.println(n*temp/gcd(temp,n));

}
static long gcd(long a, long b)
{
    if (b==0) {
        return a;
    }
    else
    return gcd(b,a%b);
}
}

import java.util.*;

public class Main{
    public static void main(String[] v) {
        Scanner s = new Scanner(System.in);
        long n = s.nextInt(), k = (long)Math.pow(10,s.nextInt()), c=n, d=k;
        while(k!=0) {
            k^=n%=k;
            k^=n^=k;
        }
        System.out.print(c*d/n);
    }
}

import java.util.Scanner;

public class TechA {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextInt();
        long k = (long) Math.pow(10, in.nextInt());

        System.out.println(gcp(n, k));
    }

    static long gcp(long n, long k) {
        return n * k / gcd(n, k);
    }

    static long gcd(long n, long k) {
        if (k == 0) {
            return n;
        }

        return gcd(k, n % k);
    }
}

    	        			/*
 * Author- Priyam Vora
 * BTech 2nd Year DAIICT
 */

        		    import java.awt.Checkbox;
import java.awt.Point;
import java.io.*;
        		    import java.math.*;
        		    import java.util.*;
import java.util.Map.Entry;

import javax.print.attribute.SetOfIntegerSyntax;
import javax.swing.plaf.FontUIResource;

        		    public class Main{
        		  	private static InputStream stream;
        		    	private static byte[] buf = new byte[1024];
        		    	private static int curChar;
        		    	private static int numChars;
        		    	private static SpaceCharFilter filter;
        		    	private static PrintWriter pw;
        		    	private static long count = 0,mod=1000000007;
        		    //	private static TreeSet<Integer> ts=new TreeSet[200000];
public final static int INF = (int) 1E9;

public static void main(String args[]) {
	InputReader(System.in);
	pw = new PrintWriter(System.out);
    new Thread(null ,new Runnable(){
       public void run(){
           try{
               solve();
               pw.close();
           } catch(Exception e){
               e.printStackTrace();
           }
       }
   },"1",1<<26).start();
   }
    static StringBuilder sb;
    public static void test(){
    	 sb=new StringBuilder();
    	int t=nextInt();
    	while(t-->0){

    		solve();
    		//pw.println();
    		//sb.append("\n");
    	}
    	pw.println(sb);
    }
    public static long pow(long n, long p,long mod) {
		if(p==0)
			return 1;
		if(p==1)
			return n%mod;
		if(p%2==0){
			long temp=pow(n, p/2,mod);
		return (temp*temp)%mod;
		}else{
			 	long temp=pow(n,p/2,mod);
			 	temp=(temp*temp)%mod;
			 	return(temp*n)%mod;

		}
	}
    public static long pow(long n, long p) {
		if(p==0)
			return 1;
		if(p==1)
			return n;
		if(p%2==0){
			long temp=pow(n, p/2);
		return (temp*temp);
		}else{
			 	long temp=pow(n,p/2);
			 	temp=(temp*temp);
			 	return(temp*n);

		}
	}
    public static void Merge(long a[],int p,int r){
        if(p<r){
            int q = (p+r)/2;
            Merge(a,p,q);
            Merge(a,q+1,r);
            Merge_Array(a,p,q,r);
        }
    }
    public static void Merge_Array(long a[],int p,int q,int r){
       long b[] = new long[q-p+1];
        long c[] = new long[r-q];
        for(int i=0;i<b.length;i++)
            b[i] = a[p+i];
        for(int i=0;i<c.length;i++)
            c[i] = a[q+i+1];
        int i = 0,j = 0;
        for(int k=p;k<=r;k++){
            if(i==b.length){
                a[k] = c[j];
                j++;
            }
            else if(j==c.length){
                a[k] = b[i];
                i++;
            }
            else if(b[i]<c[j]){
                a[k] = b[i];
                i++;
            }
            else{
                a[k] = c[j];
                j++;
            }
        }
    }

	public static long gcd(long x, long y) {
		if (x == 0)
			return y;
		else
			return gcd( y % x,x);
	}

	public static boolean isPrime(int n) {
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;

		if (n % 2 == 0 || n % 3 == 0)
			return false;

		for (int i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;

		return true;
	}

        static LinkedList<Integer> adj[];
        static boolean Visited[];
        static HashSet<Integer> exc;
        static long oddsum[]=new long[1000001];
        static long co=0,ans=0;

    	private static void buildgraph(int n){
    		adj=new LinkedList[n+1];
    		Visited=new boolean[n+1];
    		levl=new int[n+1];

    		for(int i=0;i<=n;i++){
    			adj[i]=new LinkedList<Integer>();

    		}

    	}

        static int[] levl;
        static int[] eat;
        static int n,m;
        static int price[];
        //ind frog crab
    public static void solve(){

    	long n=nextLong();
    	int k=nextInt();

    	int cnt=0;
		String s=String.valueOf(n);
		for(int j=s.length()-1;j>=0;j--){
			if((s.charAt(j)-'0')!=0)
				break;
			cnt++;
		}
		if(cnt>=k){
		pw.println(n);
		return;
		}
		int cnt2=0;
    	long temp=n;
    	while(temp%2==0){
    		temp/=2;
    		cnt2++;
    	}
    	int cnt5=0;
    	while(temp%5==0){
    		temp/=5;
    		cnt5++;
    	}
    //	pw.println(cnt5+" "+cnt2);
    	cnt5=Math.max(0, k-cnt5);
    	cnt2=Math.max(0, k-cnt2);

    	long t=1;
    	for(int i=0;i<cnt5;i++){
    		t*=5;
    	}
    	for(int i=0;i<cnt2;i++){
    		t*=2;
    	}

    	pw.println(n*t);
    }

static int no_vert=0;

  private static void dfs(int start,int cake){
	  Visited[start]=true;
	  no_vert++;
	  eat[start]=cake;
	  for(int i:adj[start]){
		  if(!Visited[i])
			  {
			//  pw.println();
			  dfs(i,cake);
			  }
	  }

  }

    public static String reverseString(String s) {
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		return (sb.toString());
	}

  /*
   private static void BFS(int sou){
    	Queue<Integer> q=new LinkedList<Integer>();
    	q.add(sou);
    	Visited[sou]=true;
    	levl[sou]=0;
    	while(!q.isEmpty()){
    		int top=q.poll();

    		for(int i:adj[top]){
    			//pw.println(i+" "+top);
			if(!Visited[i])
			{

				q.add(i);
				levl[i]=levl[top]+1;
			}

			Visited[i]=true;

			}
		}
	}*/

    		      static int indeg[];
    		   /* private static void kahn(int n){

    		    	PriorityQueue<Integer> q=new PriorityQueue<Integer>();
    				for(int i=1;i<=n;i++){
    					if(indeg[i]==0){
    						q.add(i);
    					}
    				}
    				while(!q.isEmpty()){
    					int top=q.poll();
    					st.push(top);
    					for(Node i:adj[top]){
    						indeg[i.to]--;
    						if(indeg[i.to]==0){
    							q.add(i.to);
    						}
    					}
    				}
    		    }

    		        static int state=1;
    		        static long no_exc=0,no_vert=0;
    		      static Stack<Integer> st;
    		      static HashSet<Integer> inset;
    		     /*   private static void topo(int curr){

    		        	Visited[curr]=true;
    		        	inset.add(curr);
    		        	for(int x:adj[curr]){
    		        		if(adj[x].contains(curr) || inset.contains(x)){
    		        			state=0;
    		        			return;
    		        		}
    		        		if(state==0)
    		        			return;

    		        	}
    		        	st.push(curr);

    		        	inset.remove(curr);
    		        }*/
    		        static HashSet<Integer> hs;

    		     	static boolean prime[];
					static int spf[];
					public static void sieve(int n){
						prime=new boolean[n+1];
						spf=new int[n+1];

						Arrays.fill(spf, 1);
						Arrays.fill(prime, true);
					prime[1]=false;
						spf[2]=2;

					for(int i=4;i<=n;i+=2){
						spf[i]=2;
					}
					for(int i=3;i<=n;i+=2){
						if(prime[i]){
							spf[i]=i;
							for(int j=2*i;j<=n;j+=i){

								prime[j]=false;
							if(spf[j]==1){
								spf[j]=i;
							}
							}
						}
					}

					}

    		    	// To Get Input
// Some Buffer Methods

    		     	public static void sort(long a[]){
    		     		Merge(a, 0, a.length-1);
    		     	}
    		    	public static void InputReader(InputStream stream1) {
    		    		stream = stream1;
    		    	}

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

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

    		    	private static 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++];
    		    	}

    		    	private static 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;
    		    	}

    		    	private static 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;
    		    	}

    		    	private static String nextToken() {
    		    		int c = read();
    		    		while (isSpaceChar(c))
    		    			c = read();
    		    		StringBuilder res = new StringBuilder();
    		    		do {
    		    			res.appendCodePoint(c);
    		    			c = read();
    		    		} while (!isSpaceChar(c));
    		    		return res.toString();
    		    	}

    		    	private static String nextLine() {
    		    		int c = read();
    		    		while (isSpaceChar(c))
    		    			c = read();
    		    		StringBuilder res = new StringBuilder();
    		    		do {
    		    			res.appendCodePoint(c);
    		    			c = read();
    		    		} while (!isEndOfLine(c));
    		    		return res.toString();
    		    	}

    		    	private static int[] nextIntArray(int n) {
    		    		int[] arr = new int[n];
    		    		for (int i = 0; i < n; i++) {
    		    			arr[i] = nextInt();
    		    		}
    		    		return arr;
    		    	}

    		    	private static long[][] next2dArray(int n, int m) {
    		    		long[][] arr = new long[n][m];
    		    		for (int i = 0; i < n; i++) {
    		    			for (int j = 0; j < m; j++) {
    		    				arr[i][j] = nextLong();
    		    			}
    		    		}
    		    		return arr;
    		    	}
    		    	private static char[][] nextCharArray(int n,int m){
    		    		char [][]c=new char[n][m];
    		    		for(int i=0;i<n;i++){
    		    			String s=nextLine();
    		    			for(int j=0;j<s.length();j++){
    		    				c[i][j]=s.charAt(j);
    		    			}
    		    		}
    		    		return c;
    		    	}

    		    	private static long[] nextLongArray(int n) {
    		    		long[] arr = new long[n];
    		    		for (int i = 0; i < n; i++) {
    		    			arr[i] = nextLong();
    		    		}
    		    		return arr;
    		    	}

    		    	private static void pArray(int[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}

    		    	private static void pArray(long[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}

    		    	private static void pArray(boolean[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}

    		    	private static boolean isSpaceChar(int c) {
    		    		if (filter != null)
    		    			return filter.isSpaceChar(c);
    		    		return isWhitespace(c);
    		    	}

    		    	private interface SpaceCharFilter {
    		    		public boolean isSpaceChar(int ch);
    		    	}

}

    		        class Node{
    		    	int to;
    		    	long dist;
    		    	Node(int to,long dist){
    		    		this.to=to;
    		    		this.dist=dist;
    		    	}

    		    }

class Dsu{
private int rank[], parent[] ,n;
long str[],si[],larg[];
long max=0;
int cnt=0;
private static int[] parent1;
Dsu(int size){
	this.n=size+1;
	rank=new int[n];
	cnt=n-1;
	//parent=new int[n];
    		    		    		parent=new int[n];
    		    		    		str=new long[n];
    		    		    		si=new long[n];

    		    		    		larg=new long[n];
    		    		    		makeSet();

    		    		    	}

    		    		    	void makeSet(){
    		    		    		for(int i=0;i<n;i++){
    		    		    			parent[i]=i;
    		    		    			si[i]=1;
    		    		    		}
    		    		    	}

    		    		    	int find(int x){
    		    		    		if(parent[x]!=x){

    		    		    			parent[x]=find(parent[x]);
    		    		    		}
    		    		    		return parent[x];
    		    		    	}

    		    		    	void join(int ind,long val){
    		    		    		if(str[ind]==0){
    		    		    			str[ind]=val;
    		    		    			larg[ind]=val;
    		    		    			max=Math.max(max, str[ind]);
    		    		    		}
    		    		    		int prev_ind=(ind-1);
    		    		    		int next_ind=(ind+1);
    		    		    		if(prev_ind>0 && larg[prev_ind]!=0){
    		    		    			union(prev_ind,ind);
    		    		    		}
    		    		    		if(next_ind<n && larg[next_ind]!=0){
    		    		    			union(next_ind,ind);
    		    		    		}

    		    		    	}

    		    		    	boolean union(int x,int y){
    		    		    		int xRoot=find(x);
    		    		    		int yRoot=find(y);

    		    		    		if(xRoot==yRoot)
    		    		    			return false;
    		    		    		if(rank[xRoot]<rank[yRoot]){
    		    		    		parent[xRoot]=yRoot;

    		    		    		larg[yRoot]=Math.max(larg[xRoot], larg[yRoot]);

    		    		    		si[yRoot]+=si[xRoot];
    		    		    		str[yRoot]=larg[yRoot]*si[yRoot];
    		    		    			max=Math.max(str[yRoot], max);
    		    		    		}else if(rank[yRoot]<rank[xRoot]){
    		    		    			parent[yRoot]=xRoot;

    		    		    			larg[xRoot]=Math.max(larg[xRoot], larg[yRoot]);

        		    		    		si[xRoot]+=si[yRoot];
        		    		    		str[xRoot]=larg[xRoot]*si[xRoot];
    			    		    		max=Math.max(str[xRoot], max);
    		    		    		}else{
    		    		    			parent[yRoot]=xRoot;
    		    		    			rank[xRoot]++;

    		    		    			larg[xRoot]=Math.max(larg[xRoot], larg[yRoot]);

        		    		    		si[xRoot]+=si[yRoot];
        		    		    		str[xRoot]=larg[xRoot]*si[xRoot];
    			    		    		max=Math.max(str[xRoot], max);

    		    		    		}
    		    		    		cnt--;
    		    		    		return true;
    		    		    	}

    		    		    }

//package codeforces;

import java.util.Scanner;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.TreeMap;
import java.util.TreeSet;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Set;

public class q {
	// Integer.bitCount(i); count no of 1 bit in a given number
	static Scanner scn = new Scanner(System.in);
	// static int min=Integer.MAX_VALUE;

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

	static FastReader s = new FastReader();

	static int mod = 1000000007;

	public static void main(String[] args) {
		// System.out.format("%.10f", ans);char c = sc.next().charAt(0);
		// code
		long n=scn.nextLong(),k=scn.nextLong();
		System.out.println(lcm(n,(long)Math.pow(10, k)));

	}

	public static long gcd(long a, long b) {
		if (a == 0)
			return b;
		return gcd(b % a, a);
	}
	public static long lcm(long a,long b)
	{
		return a*b/gcd(a,b);
	}

	public static long happy(int arr[][], int k, int i, long memo[][], int x) {
		int n = arr.length;
		if (i >= n)
			return 0;
		if (x >= 0 && memo[i][x] != 0)
			return memo[i][x];
		long a = Integer.MIN_VALUE, b = Integer.MIN_VALUE;
		for (int j = 0; j < 3; j++) {
			if (j != k) {
				b = happy(arr, j, i + 1, memo, j) + arr[i][j];
			}
			a = Math.max(a, b);
			memo[i][j] = a;
		}

		return a;
	}

	public static boolean[] sieveOfEratosthenes(int n) {

		boolean prime[] = new boolean[n + 1];
		for (int i = 0; i < n; i++)
			prime[i] = true;

		for (int p = 2; p * p <= n; p++) {
			// If prime[p] is not changed, then it is a prime
			if (prime[p] == true) {
				// Update all multiples of p
				for (int i = p * p; i <= n; i += p)
					prime[i] = false;
			}
		}

		for (int i = 2; i <= n; i++) {
			if (prime[i] == true) {
				// list.add(i);
			}

		}
		return prime;
	}

	public static class Pair implements Comparable {
		int x;
		int y;
		int z;

		Pair(int x, int y, int z) {
			this.x = x;
			this.y = y;
			this.z = z;
		}

		public int compareTo(Object o) {
			Pair pp = (Pair) o;
			if (pp.x == x)
				return 0;
			else if (x > pp.x)
				return 1;
			else
				return -1;
		}

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] s = reader.readLine().split("\\s+");
        //int n = Integer.parseInt(s[0]);
        //s = reader.readLine().split("\\s+");
        long a = Integer.parseInt(s[0]);
        int k = Integer.parseInt(s[1]);
        int two = 0;
        int five = 0;
        long b = a;
        while (b % 2 == 0){
            b /= 2;
            two ++;
        }
        while (b % 5 == 0){
            b /= 5;
            five++;
        }
        for (int i = 0; i < k - two; i++){
            a*=2;
        }
        for (int i = 0; i < k - five; i++){
            a*=5;
        }
        System.out.println(a);
    }
}

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		try (Scanner in = new Scanner(System.in)) {
			int n = in.nextInt();
			int k = in.nextInt();
			long ans = (long) Math.pow(10, k);
			ans = ans / BigInteger.valueOf(ans).gcd(BigInteger.valueOf(n)).longValue();
			ans = ans * n;
			System.out.println(ans);
		}
	}
}

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

public class Main {
    public static void main (String[] args) throws java.lang.Exception {
        Output out = new Output();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        long n = Long.parseLong(st.nextToken()),
            k = Long.parseLong(st.nextToken());
        long multiple_10 = (long)Math.pow(10, k);
        int gcd = GCD(Math.max(n, multiple_10), Math.min(n, multiple_10));

        out.println((n*multiple_10)/gcd);
        out.flush();

    }

    public static int GCD(long a, long b) {
        if (a%b == 0) return (int)b;
        return GCD(b, a%b);
    }

}

class Output {
    private BufferedWriter out;

    Output() {
        this.out = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    void print(String s) throws IOException {this.out.write(s);}
    void println(String s) throws IOException {this.out.write(s + "\n");}
    void println(long n) throws IOException {this.out.write(n + "\n");}
    void println(int n) throws IOException {this.out.write(n + "\n");}
    void flush () throws IOException {this.out.flush();}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int k = in.nextInt();
		if (k != 0) {
			int p = 10;
			for (int i = 0; i < k - 1; i++) {
				p *= 10;
			}
			System.out.print(lcm(n, p));
		} else System.out.print(n);

	}

	private static long gcd(int a, int b) {
		if (b == 0)
			return a;
		else
			return gcd(b, a % b);
	}

	private static long lcm(int a, int b) {
		return a / gcd(a, b) * b;
	}

}

import java.util.Scanner;

public class Krounding {
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        long k = in.nextInt();
        long t = 1;
        for (int i =0;i < k;i++){
            t= t* 10;
        }
        System.out.print(n*t/gcd(t,n));
    }
    public static long gcd(long a, long b){
        while (a != 0 && b!= 0 ){
            if (a >b){
				a = a % b;
			}else{
				b = b % a;
			}
        }
		return a+b;
    }
}

import java.util.Scanner;

public class KRounding {
    private static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }
    private static long gcd(long a, long b) {
        if (b == 0) return a;
        return gcd(b, a % b);
    }
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        long n = s.nextLong();
        long k = s.nextLong();
        System.out.println(lcm(n, (long) Math.pow(10, k)));
    }
}

import java.io.*;
import java.util.*;
public class kRounding
{
    static long gcd(long a, long b)
    {
        if(a==0)
            return b;
        return gcd(b%a,a);
    }
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        long n=sc.nextLong();
        long k=sc.nextLong();
        long z=(long)Math.pow(10,k);
        long p=z*n;
        long lcm=p/gcd(n,z);
        System.out.println(lcm);
    }
}

import java.util.Scanner;

public class N1_tech_17092017 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        long a=scanner.nextInt();
        int b=scanner.nextInt();
        //boolean flag=false;
        long res;
        //if ((a%10)%2==0)flag=true;

        long k=func(a);
        //465

        if (k>=b)res=a;else
        {
            long second =function2(a);
            long fifth=function5(a);
            long fid;
            if (second>fifth){
                fid=second-fifth;
                for (int i=0;i<fid;i++)
                {
                    if(func(a)>=b)break;
                    a*=5;
                }
            }else {
                fid=fifth-second;
                for (int i=0;i<fid;i++)
                {
                    if(func(a)>=b)break;
                    a*=2;
                }
            }
                //res=a;
                while (func(a)<b)
                {
                    a*=10;
                }
                res=a;

        }
        System.out.println(res);
    }
    public static long func(long a)
    {
        long k=0;
        while (a!=0) {
            if ((a%10)==0)k++ ;else break;
            a=a/10;
        }
        return k;
    }
    public static long function5 (long a){
        long k=0;
        while (a%5==0){
            k++;
            a/=5;
        }
        return k;
    }
    public static long function2 (long a){
        long k=0;
        while (a%2==0){
            k++;
            a/=2;
        }
        return k;
    }
    /*public static long function5 (long a){
        long k=0;
        while (a%5==0){
            k++;
            a/=5;
        }
        return k;
    }*/
}

import java.math.BigInteger;
import java.util.Scanner;

public class Krounding1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int k = input.nextInt();
	    long ans = (long)Math.pow(10,k);
	    ans = ans / BigInteger.valueOf(ans).gcd(BigInteger.valueOf(n)).longValue();
	    ans = ans*n;
	    System.out.println(ans);
	}

	private static long gcd(int a, int b){
		if(b==0)return a;
		else
			return gcd(b,a%b);
	}
	private static long lcm(int a, int b){
		return (a*b)/gcd(a,b);
	}

}

								import java.io.*;
							import java.math.BigInteger;
			import java.text.SimpleDateFormat;
			import java.util.*;

								public class Practice {
									private static InputStream stream;
									private static byte[] buf = new byte[1024];
									private static int curChar;
									private static int numChars;
									private static SpaceCharFilter filter;
									private static PrintWriter pw;
									private static long mod=1000000007;

								    public static void main(String[] args) {
								    	InputReader(System.in);
										pw = new PrintWriter(System.out);
								        new Thread(null ,new Runnable(){
								           public void run(){
								               try{
								                   solve();//This is solution method
							               pw.close();
							           } catch(Exception e){
							               e.printStackTrace();
							           }
							       }
							   },"1",1<<26).start();
								    				   }
								    public static void Merge(long a[],int p,int r){
							            if(p<r){
							                int q = (p+r)/2;
							                Merge(a,p,q);
							                Merge(a,q+1,r);
							                Merge_Array(a,p,q,r);
							            }
							        }
							        public static void Merge_Array(long a[],int p,int q,int r){
							           long b[] = new long[q-p+1];
							            long c[] = new long[r-q];
							            for(int i=0;i<b.length;i++)
							                b[i] = a[p+i];
							            for(int i=0;i<c.length;i++)
							                c[i] = a[q+i+1];
							            int i = 0,j = 0;
							            for(int k=p;k<=r;k++){
							                if(i==b.length){
							                    a[k] = c[j];
							                    j++;
							                }
							                else if(j==c.length){
							                    a[k] = b[i];
							                    i++;
							                }
							                else if(b[i]<c[j]){
							                    a[k] = b[i];
							                    i++;
							                }
							                else{
							                    a[k] = c[j];
							                    j++;
							                }
							            }
							        }
							        static StringBuilder sb=new StringBuilder();
							        public static void test(){
							        	int t=nextInt();
							        	while(t-->0){
							        		solve();

							        	}

							        }

							        public static void solve() {

							        	long n=nextLong();
							        	int k=nextInt();

							        	int cnt=0;
						        		String s=String.valueOf(n);
						        		for(int j=s.length()-1;j>=0;j--){
						        			if((s.charAt(j)-'0')!=0)
						        				break;
						        			cnt++;
						        		}
						        		if(cnt>=k){
						        		pw.println(n);
						        		return;
						        		}
						        		int cnt2=0;
							        	long temp=n;
							        	while(temp%2==0){
							        		temp/=2;
							        		cnt2++;
							        	}
							        	int cnt5=0;
							        	while(temp%5==0){
							        		temp/=5;
							        		cnt5++;
							        	}
							        //	pw.println(cnt5+" "+cnt2);
							        	cnt5=Math.max(0, k-cnt5);
							        	cnt2=Math.max(0, k-cnt2);

							        	long t=1;
							        	for(int i=0;i<cnt5;i++){
							        		t*=5;
							        	}
							        	for(int i=0;i<cnt2;i++){
							        		t*=2;
							        	}

							        	pw.println(n*t);
							        }

							        public static boolean con(char c){
							        	if(c=='a'|| c=='e'|| c=='i' || c=='o' || c=='u')
							        		return false;
							        	return true;
							        }

						    					public static long pow(long n, long p) {
						        					if(p==0)
						        						return 1%mod;
						        					if(p==1)
						        						return n%mod;
						        					if(p%2==0){
						        						long temp=pow(n, p/2);
						        					return (temp%mod*temp%mod)%mod;
						        					}else{
						        						 	long temp=pow(n,p/2);
						        						 	temp=(temp%mod*temp%mod)%mod;
						        						 	return(temp%mod*n%mod)%mod;

						        					}
						        				}

							public static boolean isVowel(char c){
								if(c=='a' || c=='i'|| c=='e' || c=='o' || c=='u')
										return true;
									return false;
								}

							    public static String reverseString(String s) {
									StringBuilder sb = new StringBuilder(s);
									sb.reverse();
									return (sb.toString());
								}
							    private static BigInteger ncr(int n,int k){
							    	if (k < 0 || k > n) return BigInteger.ZERO;
							        if (n-k < k) k = n-k;

							        BigInteger x = BigInteger.ONE;
							        for (int i = 1; i <= k; i++) {
							            x = x.multiply(new BigInteger(""+(n-i+1)));
							x = x.divide(new BigInteger(""+i));
							        }

							return x;
							    }
							    static long fact[];
							private static void factmod(int n,int mod){
								fact=new long[n+1];
								fact[0]=1;
								for(int i=1;i<=n;i++){
									fact[i]=i*fact[i-1];
									//fact[i]%=mod;

								}

							}
							private static long phi(long n){
								long ans=n;
								if(n%2==0)
									ans-=(ans/2);
								while(n%2==0)
								{
									n/=2;

								}
								for(int i=3;i*i<=n;i+=2){
									if(n%i==0){
									while(n%i==0){
										n/=i;
									}
									ans-=(ans/i);
									}
								}
								if(n>2)
									ans-=(ans/n);

								return ans;
							}
							static long d,x,y;
							static long modInverse(long A, long M)
							{
							extendedEuclid(A,M);
							return (x%M+M)%M;    //x may be negative
							}
							static void extendedEuclid(long A, long B) {
							if(B == 0) {
							d = A;
							x = 1;
							y = 0;
							}
							else {
							extendedEuclid(B, A%B);
							long temp = x;
							x = y;
							y = temp - (A/B)*y;
							}
							}
							static boolean prime[];
							static int spf[];
							public static void sieve(int n){
								prime=new boolean[n+1];
								spf=new int[n+1];

								Arrays.fill(spf, 1);
								Arrays.fill(prime, true);
							prime[1]=false;
								spf[2]=2;

							for(int i=4;i<=n;i+=2){
								spf[i]=2;
							}
							for(int i=3;i<=n;i+=2){
								if(prime[i]){
									spf[i]=i;
									for(int j=2*i;j<=n;j+=i){

										prime[j]=false;
									if(spf[j]==1){
										spf[j]=i;
									}
									}
								}
							}

							}
							public static boolean isPrime(long n) {

								if (n <= 1)
									return false;
								if (n <= 3)
									return true;

								if (n % 2 == 0 || n % 3 == 0)
									return false;

								for (long i = 5; i * i <= n; i = i + 6)
									if (n % i == 0 || n % (i + 2) == 0)
										return false;

								return true;
							}

								public static long gcd(long x, long y) {
									if (x == 0)
										return y;
									else
										return gcd( y % x,x);
								}

								public static void InputReader(InputStream stream1) {
									stream = stream1;
								}

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

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

								private static 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++];
								}

								private static 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;
								}

								private static 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;
								}

								private static String nextToken() {
									int c = read();
									while (isSpaceChar(c))
										c = read();
									StringBuilder res = new StringBuilder();
									do {
										res.appendCodePoint(c);
										c = read();
									} while (!isSpaceChar(c));
									return res.toString();
								}
								private static double[] nextDoubleArray(int n) {
									double arr[]=new double[n];
									String a[]=nextLine().split(" ");
									for(int i=1;i<n;i++){
										arr[i]=Double.parseDouble(a[i-1]);
									}
									return arr;
								}
								private static String nextLine() {
									int c = read();
									while (isSpaceChar(c))
										c = read();
									StringBuilder res = new StringBuilder();
									do {
										res.appendCodePoint(c);
										c = read();
									} while (!isEndOfLine(c));
									return res.toString();
								}

								private static int[] nextIntArray(int n) {
									int[] arr = new int[n];
									for (int i = 0; i < n; i++) {
										arr[i] = nextInt();
									}
									return arr;
								}

								private static long[][] next2dArray(int n, int m) {
									long[][] arr = new long[n][m];
									for (int i = 0; i < n; i++) {
										for (int j = 0; j < m; j++) {
											arr[i][j] = nextLong();
										}
									}
									return arr;
								}
								private static char[][] nextCharArray(int n,int m){
									char [][]c=new char[n][m];
									for(int i=0;i<n;i++){
										String s=nextLine();
										for(int j=0;j<s.length();j++){
											c[i][j]=s.charAt(j);
										}
									}
									return c;
								}

								private static long[] nextLongArray(int n) {
									long[] arr = new long[n];
									for (int i = 0; i < n; i++) {
										arr[i] = nextLong();
									}
									return arr;
								}

								private static void pArray(int[] arr) {
									for (int i = 0; i < arr.length; i++) {
										pw.print(arr[i] + " ");
									}
									pw.println();
									return;
								}

								private static void pArray(long[] arr) {
									for (int i = 0; i < arr.length; i++) {
										pw.print(arr[i] + " ");
									}
									pw.println();
									return;
								}

								private static void pArray(boolean[] arr) {
									for (int i = 0; i < arr.length; i++) {
										pw.print(arr[i] + " ");
									}
									pw.println();
									return;
								}

								private static boolean isSpaceChar(int c) {
									if (filter != null)
										return filter.isSpaceChar(c);
									return isWhitespace(c);
								}

								private interface SpaceCharFilter {
									public boolean isSpaceChar(int ch);
								}

							}
								 class Hashing {

									  static final int multiplier = 43;
									  static final Random rnd = new Random();
									  static final int mod1 = BigInteger.valueOf((int) (1e9 + rnd.nextInt((int) 1e9))).nextProbablePrime().intValue();
									  static final int mod2 = BigInteger.valueOf((int) (1e9 + rnd.nextInt((int) 1e9))).nextProbablePrime().intValue();
									  static final int invMultiplier1 = BigInteger.valueOf(multiplier).modInverse(BigInteger.valueOf(mod1)).intValue();
									  static final int invMultiplier2 = BigInteger.valueOf(multiplier).modInverse(BigInteger.valueOf(mod2)).intValue();

									  long[] hash1, hash2;
									  long[] inv1, inv2;
									  int n;

									  public Hashing(String s) {
									    n = s.length();
									    hash1 = new long[n + 1];
									    hash2 = new long[n + 1];
									    inv1 = new long[n + 1];
									    inv2 = new long[n + 1];
									    inv1[0] = 1;
									    inv2[0] = 1;

									    long p1 = 1;
									    long p2 = 1;
									    for (int i = 0; i < n; i++) {
									      hash1[i + 1] = (hash1[i] + s.charAt(i) * p1) % mod1;
									      p1 = p1 * multiplier % mod1;
									      inv1[i + 1] = inv1[i] * invMultiplier1 % mod1;
									      hash2[i + 1] = (hash2[i] + s.charAt(i) * p2) % mod2;
									      p2 = p2 * multiplier % mod2;
									      inv2[i + 1] = inv2[i] * invMultiplier2 % mod2;
									    }
									  }

									  public long getHash(int i, int r) {
										//  i--;
									    return (((hash1[r] - hash1[i] + mod1) * inv1[i] % mod1) << 32)
									        + (hash2[r] - hash2[i] + mod2) * inv2[i] % mod2;
									  }
								}
										 class Pair implements Comparable <Pair>{
											 long val,no_of_black;
											 Pair(long val,long no_of_black){
												 this.val=val;
												 this.no_of_black=no_of_black;
											 }
											 @Override
											 public int compareTo(Pair o){
												 return 0;
											 }

										 }

import java.util.Scanner;

public class k_round {
    private int n;
    private int k;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        k_round kRound =new k_round();
        kRound.n=in.nextInt();
        kRound.k=in.nextInt();
        System.out.println(kRound.realround());
    }
    long gcd(long a,long b){
        return b == 0 ? a : gcd(b,a % b);
    }
    long lcm(long a,long b){
        return a / gcd(a,b) * b;
    }

    public long realround()
    {
        long s=1*(long)Math.pow(10,k);

        s=lcm(s,n);

return s;

  }

}

import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.lang.Math;
import java.math.BigInteger;

public class Problem {
	class Pair {
		int x, y;

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

	void solve() throws IOException {
		int n = rI();
		int k = rI();

		int pow5 = 0;
		int pow2 = 0;

		long ans = n;

		while(n%5==0){
			pow5++;
			n/=5;
		}

		while(n%2==0){
			pow2++;
			n/=2;
		}
		for(int i=0;i<k-pow5;++i){
			ans*=5;
		}
		for(int i=0;i<k-pow2;++i){
			ans*=2;
		}
		out.println(ans);
	}

	int checkBit(int mask, int bit) {
		return (mask >> bit) & 1;
	}

	public static void main(String[] args) throws IOException {

		new Problem().run();
	}

	boolean isLower(char a) {
		return ((int) a) >= 97 ? true : false;
	}

	long INF = Integer.MAX_VALUE - 12345;

	int[][] STEPS = { { 0, 1 }, { 1, 0 }, { -1, 0 }, { 0, -1 } };

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;
	Random rnd = new Random();
	static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	Problem() throws FileNotFoundException {

		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
		tok = new StringTokenizer("");
	}

	long checkBit(long mask, int bit) {
		return (mask >> bit) & 1;
	}

	// ======================================================

	// ======================================================
	void run() throws IOException {
		solve();
		out.close();
	}

	char[] reverseCharArray(char[] arr) {
		char[] ans = new char[arr.length];
		for (int i = 0; i < arr.length; ++i) {
			ans[i] = arr[arr.length - i - 1];
		}
		return ans;
	}

	int sqrt(double m) {
		int l = 0;
		int r = 1000000000 + 9;
		int i = 1000;
		while (r - l > 1) {
			int mid = (r + l) / 2;
			if (mid * mid > m) {
				r = mid;
			} else {
				l = mid;
			}
		}
		return l;
	}

	int countPow(int m, int n) {
		int ans = 0;
		while (m % n == 0 && m > 0) {
			ans++;
			m /= n;
		}
		return ans;
	}

	long binPow(long a, long b) {
		if (b == 0) {
			return 1;
		}
		if (b % 2 == 1) {
			return a * binPow(a, b - 1);
		} else {
			long c = binPow(a, b / 2);
			return c * c;
		}

	}

	int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	long pow(long x, long k) {
		long ans = 1;
		for (int i = 0; i < k; ++i) {
			ans *= x;
		}
		return ans;
	}

	// ////////////////////////////////////////////////////////////////////

	String delimiter = " ";

	String readLine() throws IOException {
		return in.readLine();
	}

	String rS() throws IOException {
		while (!tok.hasMoreTokens()) {
			String nextLine = readLine();
			if (null == nextLine)
				return null;

			tok = new StringTokenizer(nextLine);
		}

		return tok.nextToken(delimiter);
	}

	int rI() throws IOException {
		return Integer.parseInt(rS());
	}

	long rL() throws IOException {
		return Long.parseLong(rS());
	}

	double rD() throws IOException {
		return Double.parseDouble(rS());
	}

	int[] rA(int b) {
		int a[] = new int[b];
		for (int i = 0; i < b; i++) {
			try {
				a[i] = rI();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return a;
	}

	int[] readSortedIntArray(int size) throws IOException {
		Integer[] array = new Integer[size];

		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}

	int[] sortedIntArray(int size, int[] array) throws IOException {
		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}
}

/*
 * 861 A. k-rounding
 */

import java.util.Scanner;

public class KRounding {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		long a, b;
		a = s.nextLong();
		b = s.nextLong();
		for(long i=0;i<b;i++) {
			if(a%2==0) {
				a/=2;
			}
			if(a%5==0) {
				a/=5;
			}
		}
		System.out.print((int)a);
		for(long i=0;i<b;i++) {
			System.out.print("0");
		}
	}
}

import java.util.*;

public class Codeforces {

    public static int count(String p){
		int counts=0;
		for(int i=p.length()-1;i>=0;i--){

			if(p.charAt(i)!='0')
				return counts;
			else
				counts++;

		}

		return counts;
	}

	public static void main(String[] args) {

		Scanner sc=new Scanner(System.in);

		long n=sc.nextLong();
		int k=sc.nextInt();

		String p=""+n;

		if(count(p)>=k)
			System.out.println(n);
		else{
			//System.out.println("not term at first");

			int last=Integer.parseInt(""+p.charAt(p.length()-1));

			if(last==1 || last==3 || last==7 || last==9){

				for(int i=1;i<=k;i++)
					p=p+"0";

				System.out.println(p);

			}
			else{

				while(count(p)<k){
					//System.out.println("count was "+count(p));
					int index=-1;
					for(int i=p.length()-1;i>=0;i--){

						if(p.charAt(i)!='0'){
							index=i;
							break;
						}

					}

					last=Integer.parseInt(""+p.charAt(index));
					//System.out.println("last is "+last);
					if(last==2 || last==4 || last==6 || last==8){
						n=n*5;
						p=""+n;
					}
					else if(last==5){
						n=n*2;
						p=""+n;
					}
					else if(last==1 || last==3 || last==7 || last==9){
						int rem=k-count(p);
						for(int i=1;i<=rem;i++)
							p=p+"0";

						break;

					}

				}

				System.out.println(p);

			}

		}

	}
}

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

public final class Main {

    public static void main(String[] args) throws Exception {
        PrintWriter pw = new PrintWriter(System.out);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        //By definition, we are trying to find the smallest positive integer
        //which is divisible by both n and 10^m. This is because if we
        //expect our answer to have m zeros then it must divide by 10^m evenly.
        //Then we just return the LCM of n and 10^m.

        pw.println(lcm(n, (long)Math.pow(10, m)));
        pw.close();
    }

    public static long lcm(long a, long b){
        return a*b / gcd(a, b);
    }

    public static long gcd(long a, long b){
        return b == 0 ? a : gcd(b, a%b);
    }
}

import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.System.*;
public class A
{
public static void main (String args[]) throws Exception
{
	 Scanner sc=new Scanner(in);
	 long n=sc.nextLong();
	 long k=sc.nextLong();
	 long x=(long)(Math.pow(10,k));
	 long ans=GCD(x,n);
	 ans=(n*x)/ans;
	 out.println(ans);

 }
 public static long GCD(long a, long b) {
    if (b==0) return a;
    return GCD(b,a%b);
}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {
    static long gcd(long a, long b){
        BigInteger l = BigInteger.valueOf(a);
        BigInteger r = BigInteger.valueOf(b);
        return l.gcd(r).longValue();
    }

    static long lcm(long a, long b){
        return (a * b) / gcd(a, b);
    }
    public static void main(String args[]) throws Exception {
        init("in.txt", "out.txt");
        long n = nextLong();
        long k = nextInt();

        out.println(lcm(n, (long) Math.pow(10L, k)));
        out.close();
    }

    static BufferedReader scan;
    static PrintWriter out;
    static StringTokenizer st;

    static void init() {
        scan = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    static void init(String name1, String name2) throws Exception {
        try {
            scan = new BufferedReader(new FileReader(name1));
            out = new PrintWriter(name2);
        } catch (Exception e) {
            scan = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    static String next() throws Exception {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(scan.readLine());
        return st.nextToken();
    }

    static int nextInt() throws Exception {
        return Integer.parseInt(next());
    }

    static long nextLong() throws Exception {
        return Long.parseLong(next());
    }
}

import java.util.*;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;

public class Es
{
	static class Pair
	{
		int first;
		double second;
		public Pair(int f, double s)
		{
			first = f;
			second = s;
		}

		public String toString()
		{
			return first + " " + second;
		}
	}

	static class PairComparator implements Comparator <Pair>
	{
		public int compare(Pair p1, Pair p2)
		{
			if(p1.first < p2.first)
				return -1;
			if(p1.first > p2.first)
				return 1;
			if(p1.second < p2.second)
				return -1;
			if(p1.second > p2.second)
				return 1;
			return 0;
		}
	}

	static int log2(double a)
	{
		return (int)(Math.log(a) / Math.log(2));
	}

	static long gcd(long a, long b)
	{
		long r;
		while((r = a % b) > 0)
		{
			a = b;
			b = r;
		}
		return b;
	}

	static class TrieNode
	{
		TrieNode z, o;
		boolean end;
		long count;

		public TrieNode()
		{
			 z = null;
			 o = null;
			 count = 0;
			 end = false;
		}
	}

	static long fun(long n)
	{
		long ans = 0;
		while(n % 10 == 0)
		{
			ans ++;
			n /= 10;
		}
		return ans;
	}

	public static void main(String[] args) throws IOException
	{
		long n = in.nextInt();
		long k = in.nextInt();
		int c = 0;
		while(c < k)
		{
			long d = n / (int)Math.pow(10, c) % 10;
			for(int i = 1; i <= 10; i ++)
				if(d * i % 10 == 0)
				{
					n *= i;
					break;
				}
			c ++;
		}
		sop(n);
	}

	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader in = new FastReader();

    public static void sop(Object o)
    {
    	System.out.print(o);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
import java.math.BigInteger;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Ocykat
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Prob861A solver = new Prob861A();
        solver.solve(1, in, out);
        out.close();
    }

    static class Prob861A {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long rn = in.nextLong();
            int k = in.nextInt();
            if (k == 0) {
                out.println(rn);
                return;
            }
            BigInteger n = new BigInteger(Long.toString(rn));
            BigInteger nn = n;
            int pnZeros = numberOfZero(n);
            int nnZeros = pnZeros;
            int cnt = 2;
            while ((nnZeros < k)) {
                nn = n.multiply(BigInteger.valueOf(cnt));
                nnZeros = numberOfZero(nn);
                if (pnZeros != nnZeros) {
                    cnt = 0;
                    n = nn;
                }
                pnZeros = nnZeros;
                cnt += 1;
            }
            out.println(nn);
            return;
        }

        private int numberOfZero(BigInteger n) {
            int res = 0;
            while (n.mod(BigInteger.TEN).equals(BigInteger.ZERO)) {
                n = n.divide(BigInteger.TEN);
                res++;
            }
            return res;
        }

    }
}

import java.util.Scanner;

public class KRound {

    static Scanner sc = new Scanner(System.in);
    public static void main(String... args) {
        int n = sc.nextInt(), k = sc.nextInt();
        int t = 1;
        while (!checkForZeros(n * t, k)) {
            t++;
        }
        System.out.println(n * t);
    }

    public static boolean checkForZeros(int a, int k) {
        return a % power(10, k) == 0;
    }

    private static int power(int n, int p) {
        int res = 1;
        for (int i = 0; i < p; i++)
            res *= n;
        return res;
    }

}

import java.util.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;

public class Main
{

  public static void main(String[] args) throws Exception
  {
    long startTime = System.nanoTime();
    long n=in.nextInt();
    int k=in.nextInt();
    int two=count_primes(n,2);
    int target_two=k;
    int target_five=k;
    int five=count_primes(n,5);
    if(k<=Math.min(two,five))
    {
        out.println(n);
    }
    else
    {
        target_two-=two;
        target_five-=five;
        out.println((long)(n*Math.pow(2,target_two)*Math.pow(5,target_five)));
    }
    long endTime = System.nanoTime();
    err.println("Execution Time : +" + (endTime-startTime)/1000000 + " ms");
    exit(0);
  }

static int count_primes(long n,int p)
{
    int count=0;
    while(n>0 && n%p==0)
    {
        count++;
        n/=p;
    }
    return count;
}

  static class InputReader
  {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

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

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

    static void exit(int a)
    {
      out.close();
      err.close();
      System.exit(a);
    }

    static InputStream inputStream = System.in;
    static OutputStream outputStream = System.out;
    static OutputStream errStream = System.err;
    static InputReader in = new InputReader(inputStream);
    static PrintWriter out = new PrintWriter(outputStream);
    static PrintWriter err = new PrintWriter(errStream);
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n=sc.nextInt();
        long k=sc.nextInt();
        long two=0;
        long five=0;
        long a=n;
        while(a%5==0){
            five++;
            a/=5;
        }
        while(a%2==0){
            two++;
            a/=2;
        }
        long ans=1;
        if(five>two){
            ans*=(int)Math.pow(2,five-two);
        }else{
            if(two>five) {
                ans *= (int) Math.pow(5, two - five);
            }
        }
        if(five-two!=0||(two==0&&five==0)) {
            ans *= (int) Math.pow(10, k - Math.abs(five - two)) * n;
        }else{
            ans*=n;
        }
        System.out.println(ans);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

            if (k == 0) {
                out.println(n);
                return;
            } else if (n % Math.pow(10, k) == 0) {
                out.println(n);
                return;
            }

            long cnt = 0;
            long reqn = n;
            while (reqn % 5 == 0) {
                ++cnt;
                reqn /= 5;
            }

            long cnt2 = 0;
            long reqN = n;
            while (reqN % 2 == 0) {
                ++cnt2;
                reqN /= 2;
            }

            if (cnt > cnt2) {
                cnt -= cnt2;
                n *= Math.pow(2, cnt);
                while ((long) (n % Math.pow(10, k)) != 0)
                    n = (long) (n * 10);
                out.println(n);
            } else if (cnt2 > cnt) {
                cnt2 -= cnt;
                n *= Math.pow(5, cnt2);
                while (n % Math.pow(10, k) != 0)
                    n *= 10;
                out.println(n);
            } else {
                long temp = (long) Math.pow(10, k);
                String tempS = String.format("%s", temp).substring(1);
                out.println(n + "" + tempS);
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

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

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.Scanner;

public class H {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		int k=sc.nextInt();

		int max2=0;
		int max5=0;

		for(int i=0;i<9;i++){
			if(n%Math.pow(2,i)==0){
				max2=i;
			}
			if(n%Math.pow(5,i)==0){
				max5=i;
			}
		}
		long pot2=(long)Math.pow(2,k-max2);
		long pot5=(long)Math.pow(5,k-max5);
		System.out.print(n*pot2*pot5);

	}

}

import java.util.*;
import java.io.*;
public class Main {
    public static long gcd(long p, long q) {
        if (q == 0) return p;
        return gcd(q, p % q);
    }
    private static long lcm(long a, long b)
    {
        return a * (b / gcd(a, b));
    }
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long n = in.nextInt();
        long k = in.nextInt();
        if (k==0) {
            out.println(n);
            out.flush();
            return;
        }
        long rememberk = k;
        k = (long)Math.pow(10,k);
        long lcm1 = lcm(n,k);
        long lcm2 = lcm(10*rememberk,lcm1);
        out.println(lcm2);

        out.flush();
    }
}

import java.util.Scanner;

public class Krounding {

	public static void main(String args[]) {
			Scanner sc = new Scanner(System.in);
			long n = sc.nextLong();
			long k = sc.nextLong();
			long num = (long) Math.pow(10, k);
			long answer = 0;
			if (k == 0) {
				answer = num;
			} else if (num < n && k > 1) {
				answer = n * num;
			} else {
				long m = num;
				while (true) {
					if (m % n == 0) {
						answer = m;
						break;
					} else {
						m += num;
					}
				}
			}
			System.out.println(answer);
			sc.close();
	}
}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class bbg
{
	public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static int vizitat[];
public static int x;

	public static void main (String[] args) throws java.lang.Exception
{

Scanner input=new Scanner(System.in);

HashMap<Integer, Integer> contor1= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> contor2= new HashMap<Integer, Integer>();

HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> stop= new HashMap<Integer, Integer>();

		Long n=input.nextLong();
		Long k=input.nextLong();

		if(k==0) System.out.println(n);

		else if (cifrezero(n)>=k) System.out.println(n);

		else{

		int number=0;
			Long rasp=n;
		int x=0;

		for(int i=1;i<=10;i++)
		{

		    Long prod=n*i*1L;

		  //  System.out.println(i+" "+prod+" ");

		    if(cifrezero(prod)>number) {rasp=prod; number=cifrezero(prod);}

		  else   if(cifrezero(prod)==number && prod<rasp ) {rasp=prod;
		    number=cifrezero(prod);}

		}

		System.out.print(rasp);

	for(int j=1;j<=k-cifrezero(rasp);j++) System.out.print("0");

		}

		}

		public static int cifrezero(Long nr){

			Long part=nr;
			int contor=0;
			while(part>0l && part%10==0){
				contor++;
				part=part/10l;

			}

			return contor;

		}

		}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Arrays;

public class Solution
{

    public static void main(String[] args) {
        Reader in = new Reader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt() ,
                k = in.nextInt() ,
                z = getZeroes(n) , max2 , max5;
        long res;
        boolean toCont = true;

        max2 = getMaxPow(n , 2);
        max5 = getMaxPow(n , 5);

        res = (long) (Math.pow(2 , k - max2) * Math.pow(5 , k - max5) * n);

        out.println(res);
        out.close();
    }

    public static int getMaxPow(int val , int div)
    {
        int pow = 0;
        while(val % Math.pow(div , pow) == 0) { pow++; }
        return pow - 1;
    }

    public static int getZeroes(int val)
    {
        int z = 0 , pow = 10;
        while(val % pow == 0)
        {
            pow *= 10;
            z++;
        }
        return z;
    }

    static class Reader
    {

        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public Reader(InputStream in)
        {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

        public String next()
        {
            while(tokenizer == null || !tokenizer.hasMoreTokens())
            {
                try
                {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }
            return tokenizer.nextToken();
        }

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

    }

}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		long n=sc.nextLong();
		long k=sc.nextLong();
		long mid=n;

		long count=1;
		while(mid%10==0){
			if(k==0)break;
			k--;
			mid=mid/10;
		}

		while(mid%5==0){
			if(k==0)break;
			count=count*2;
			k--;
			mid=mid/5;

		}
		while(k-->0){
			count=count*10;
		}
		System.out.println(n*count);

	}

}

import java.util.*;

public class KRounding {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        long c = (long) Math.pow(10, k);
        long a = 2;
        int b = 1;
        String s = String.valueOf(n);
        int p = s.charAt(s.length() - 1) - '0';
        if (p == 2 || p == 4 || p == 5 || p == 8 || p == 6) {
            b = 2;
            for (long i = n; i <= c * n;) {
                if (i % n == 0 && i % c == 0) {
                    a = i;
                    break;
                }
                i = n * b;
                b = b + 2;
            }
        } else if (p == 3 || p == 7 || p == 1 || p == 0) {
            b = 5;
            for (long i = n; i <= c * n;) {
                if (i % n == 0 && i % c == 0) {
                    a = i;
                    break;
                }
                i = n * b;
                b=b+5;
            }
        } else {
            a = n;
            a = n * c;
        }
        System.out.println(a);
    }
}

    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.*;

    public class Main
    {
        static class Reader
        {
            final private int BUFFER_SIZE = 1 << 16;
            private DataInputStream din;
            private byte[] buffer;
            private int bufferPointer, bytesRead;

            public Reader()
            {
                din = new DataInputStream(System.in);
                buffer = new byte[BUFFER_SIZE];
                bufferPointer = bytesRead = 0;
            }

            public Reader(String file_name) throws IOException
            {
                din = new DataInputStream(new FileInputStream(file_name));
                buffer = new byte[BUFFER_SIZE];
                bufferPointer = bytesRead = 0;
            }

            public String readLine() throws IOException
            {
                byte[] buf = new byte[64]; // line length
                int cnt = 0, c;
                while ((c = read()) != -1)
                {
                    if (c == '\n')
                        break;
                    buf[cnt++] = (byte) c;
                }
                return new String(buf, 0, cnt);
            }

            public int nextInt() throws IOException
            {
                int ret = 0;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();
                do
                {
                    ret = ret * 10 + c - '0';
                }  while ((c = read()) >= '0' && c <= '9');

                if (neg)
                    return -ret;
                return ret;
            }

            public long nextLong() throws IOException
            {
                long ret = 0;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();
                do {
                    ret = ret * 10 + c - '0';
                }
                while ((c = read()) >= '0' && c <= '9');
                if (neg)
                    return -ret;
                return ret;
            }

            public double nextDouble() throws IOException
            {
                double ret = 0, div = 1;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();

                do {
                    ret = ret * 10 + c - '0';
                }
                while ((c = read()) >= '0' && c <= '9');

                if (c == '.')
                {
                    while ((c = read()) >= '0' && c <= '9')
                    {
                        ret += (c - '0') / (div *= 10);
                    }
                }

                if (neg)
                    return -ret;
                return ret;
            }

            private void fillBuffer() throws IOException
            {
                bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
                if (bytesRead == -1)
                    buffer[0] = -1;
            }

            private byte read() throws IOException
            {
                if (bufferPointer == bytesRead)
                    fillBuffer();
                return buffer[bufferPointer++];
            }

            public void close() throws IOException
            {
                if (din == null)
                    return;
                din.close();
            }
        }
        public static void main(String[] args) throws IOException {

            Reader s = new Reader();

            long n = s.nextLong();
            int k = s.nextInt();

            int num5 = 0;
            int num2 = 0;

            while (n % 5 == 0) {
                n /= 5;
                num5++;
            }
            while (n % 2 == 0) {
                n /= 2;
                num2++;
            }

            System.out.println((int) Math.pow(2, Math.max(k - num2, 0)) * (int) Math.pow(5, Math.max(k - num5, 0)) * n);

            }
    }

import java.io.*;
import java.util.*;
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
import java.lang.*;
public class Solution{

	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		long n = in.nextLong();
		long m = in.nextLong();
		long ans = 0;
		long index = 0;
		long temp = m;
		while(temp>0){
		    if(index==0){
		        index++;
		    }
		    else{
		        index*=10;
		    }
		    temp--;
		}
		index*=10;
		long index2 = index;
		if(m==0 || m == 1){
		    System.out.println(n);
		}
		else{
		    ans = lcm(n,index);
		    System.out.println(ans);
		}
	}
	public static long lcm(long a, long b){
	    return a * b / gcd(a,b);
	}
	public static long gcd(long a, long b){
	    if(b==0){
	        return a;
	    }
	    return gcd(b, a%b);
	}
}

//package competitive;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Vector;
public class A861 {
	/*public static long gcd (long a,long b)
	{
		if(b==0)
			return a;
		return gcd(b,a%b);
	}
	public static long bs(long l,long r,long val,long n)
	{ long mid,ans;
		long temp;

		if(l<r)
		{
			mid=(l+r)/2;
			temp=mid*n;
			if(temp%val==0)
				{r=mid-1;ans=mid;}
			else
			{

			}
		}

	}*/
	public static void main(String args[])throws IOException
	{
		BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
		String s=br.readLine();
		String str[]=s.trim().split(" ");
		long n=Long.parseLong(str[0]);
		long k=Long.parseLong(str[1]);
		long val=1,i;
		for( i=0;i<k;++i)
		{
			val*=10;
		}
		/*long temp=n,c=0;
		while(temp%10==0 && temp>0)
		{++c;temp/=10;
		}
		temp=1;
		for(i=0;i<k-c;++i)
		{
		temp*=10;
		}*/

		//long r=temp;
		long ans=n,temp;
		long l=ans%10;;
		//System.out.println(l+" "+r+" "+ans+" "+val+" "+n);

		if((ans%val)!=0)
		{
			if(l!=0 && l%2==0)
				ans*=5;
			else if(l!=0 && l%2==1 && l!=5)
				ans*=10;
			else if(l==5)
				ans*=2;
			else
				ans*=10;
		}
		if(ans%val==0)
		{System.out.print(ans);return;}
	/*	long r=val/1000000;
		//System.out.println("anss"+ans);
		while(r>0 && ans%r!=0)
		{
			ans*=10;
		}*/
		//System.out.println(ans+" "+r);
		for(i=2;i<=10000000;++i)
		{	temp=ans*i;
			if(temp%val==0)
				{ans=temp;break;}
		}

		System.out.println(ans);
	}

}

import java.util.Scanner;

public class Solution {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		int k = sc.nextInt();

		int existingZeros = noOfZeros(n);
		int requiredZeros = k - existingZeros;

		if (requiredZeros <= 0) {
			System.out.println(n);
		} else {
			while (n % 10 == 0)
				n = n / 10;

			while (n % 5 == 0)
				n = n / 5;

			while(k-- > 0)
				n = n * 10;
			System.out.println(n);
		}

	}

	private static int noOfZeros(long n ) {
		int count = 0;
		while (n % 10 == 0) {
			count++;
			n = n / 10;
		}

		return count;
	}

	private static int noOfFives(long n) {
		int count = 0;
		while (n % 5 == 0) {
			count++;
			n = n / 5;
		}
		return count;
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class _858c_A implements Runnable{
    public static void main(String[] args) {
	    new Thread(null, new _858c_A(),"Main",1<<27).start();
    }
    @Override
    public void run() {
        FastReader fd = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int t = fd.nextInt();
        int k = fd.nextInt();
        out.print(t);
        for(int i = 0;i < k; i++){out.print("0");}
        out.println();
        out.close();
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.util.Scanner;

public class KRounding{
	public static void main (String[] args) {
		Scanner kbd = new Scanner(System.in);
		long x, y;

		x = kbd.nextLong();
		y = kbd.nextLong();
		for(long i = 0; i < y; i++){
			if(x % 2 == 0){
				x/= 2;
			}
			if(x % 5 == 0){
				x/= 5;
			}
		}
		System.out.println((int)x);

		for(long i = 0; i < y; i++){
			System.out.print("0");
		}

	}
}

import java.util.Scanner;

public class KRounding {
    private Scanner reader = new Scanner(System.in);

    public static void main (String[] args){
        new KRounding().solve();
    }

    private void solve () {
        int k ;
        int n ;

        n = reader.nextInt();
        k = reader.nextInt();

        int aNumber = (int) Math.pow(10,k);

        System.out.println( (n*aNumber)/ GCD(n,aNumber) );
    }

    private int GCD (int a , int b){
        if (b == 0) return a;
        return GCD ( b , a%b );
    }
}

import java.util.Scanner;

public class TaskA {

    public static void main(String[] args) {
        Solver();
    }

    static void Solver() {
        Scanner in = new Scanner(System.in);
        long n = in.nextInt(), k= in.nextInt(), ans;
        long ar[] = new long [9];
        int len = 0;
        for (int i = 1; i <= 9; i++)
        {
            long t = n * i;
            ar[len++] = Add(t, k);
        }
        ans = SeekMin(ar, 9);
        System.out.println(ans);
    }

    static long Add(long a, long k)
    {
        long r = 0, rem = a;
        while (a % 10 == 0)
        {
            r++;
            a /= 10;
        }
        a = rem;
        for (long i = r; i < k; i++)
            a *= 10;
        return a;
    }

    static long SeekMin(long a[], long l)
    {
        long min = a[0];
        for (int i = 1; i < l; i++)
            if (a[i] < min)
                min = a[i];
        return min;
    }
}

import java.util.Scanner;

public class KRound {

    static Scanner sc = new Scanner(System.in);
    public static void main(String... args) {
        int n = sc.nextInt(), k = sc.nextInt();
        int t = 1;
        while (!checkForZeros(n * t, k)) {
            t++;
        }
        System.out.println(n * t);
    }

    public static boolean checkForZeros(long a, int k) {
        return a % power(k) == 0;
    }

    private static int power(int p) {
        int res = 1;
        for (int i = 0; i < p; i++)
            res *= 10;
        return res;
    }

}

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

	public class A861
	{
		public static void main(String[] args)
		{
			InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);

			long n = in.nextLong();
			long k = in.nextLong();
			long p = (long)Math.pow(10, k),temp=n,count=0;

			while(temp%p!=0 && temp%n==0)
			{
				while(temp%10==0)
				{
					temp=temp/10;
					count++;
				}

				if(temp%5==0)
				{
					temp=temp*2;
				}
				else if(temp%2==0)
				{
					temp=temp*5;
				}
				else
					temp=temp*10;

				temp=temp*(long)Math.pow(10, count);
			}

			pw.println(temp);

			pw.flush();
			pw.close();
		}

		static class InputReader
		{

			private final InputStream stream;
			private final byte[] buf = new byte[8192];
			private int curChar, snumChars;
			private SpaceCharFilter filter;

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

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

			public int nextInt()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
			    {
					sgn = -1;
					c = snext();
				}
				int res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

			public long nextLong()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
				{
					sgn = -1;
					c = snext();
				}
				long res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

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

			public String readString()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isSpaceChar(c));
				return res.toString();
			}

			public String nextLine()
			{
				int c = snext();
				while (isSpaceChar(c))
					c = snext();
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isEndOfLine(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;
			}

			private boolean isEndOfLine(int c)
			{
				return c == '\n' || c == '\r' || c == -1;
			}

			public interface SpaceCharFilter
		    {
				public boolean isSpaceChar(int ch);
			}
		}
	}

//package CF_434;

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

public class A {
	public static void main(String[] args) throws Exception{ new A(new Reader()); }
	public A(Reader rr) throws IOException{
		long n=rr.nl(), k=rr.nl();
		boolean ok=true;
		for(int i=1; i<=k; i++){
			if(n%(Math.pow(10, i))!=0) ok=false;
		}
		if(!ok){
			for(int i=1; i<=k; i++){
				long lastDig=n%(int)Math.pow(10, i);
				if(lastDig==0||lastDig==1||lastDig==3||lastDig==7||lastDig==9){
					break;
				}else{
					if(lastDig==2||lastDig==4||lastDig==6||lastDig==8) n*=5;
					if(lastDig==5) n*=2;
				}
			}
			for(int i=1; i<=k; i++){
				if(n%(Math.pow(10, i))!=0) n*=10;
			}
		}
		System.out.println(n);
	}
	static class Reader{
		private DataInputStream din;
		private byte[] buffer=new byte[1024];
		private int bufP, bytR;
		public Reader() throws IOException{
			din=new DataInputStream(System.in);
			bufP=bytR=0;
		}
		public Reader(String file) throws IOException{
			din=new DataInputStream(new FileInputStream(file));
			bufP=bytR=0;
		}
		private String rl() throws IOException{
			byte[] buf=new byte[1024];
			int cnt=0, c;
			while((c=read())!=-1){
				if(c=='\n') break;
				buf[cnt++]=(byte)c;
			}
			return new String(buf, 0, cnt);
		}
		private int ni() throws IOException{
			int num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private long nl() throws IOException{
			long num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private double nd() throws IOException{ return Double.parseDouble(ns()); }
		private char nc() throws IOException{ return (char)next(); }
		private String ns() throws IOException{
			int c=next();
			StringBuilder sb=new StringBuilder();
			while(!(isChar(c))){
				sb.appendCodePoint(c);
				c=read();
			}
			return sb.toString();
		}
		private char[] ns(int n) throws IOException{
			char[] buf=new char[n];
			int c=next(), r=0;
			while(r<n&&!(isChar(c))){
				buf[r++]=(char)c;
				c=next();
			}
			return n==r?buf:Arrays.copyOf(buf, r);
		}
		private char[][] nm(int n, int m) throws IOException{
			char[][] map=new char[n][];
			for(int i=0; i<n; i++) map[i]=ns(m);
			return map;
		}
		private int[] na(int n) throws IOException{
			int[] a=new int[n];
			for(int i=0; i<n; i++) a[i]=ni();
			return a;
		}
		private boolean isChar(int c) throws IOException{ return !(c>=33&&c<=126); }
		private int next() throws IOException{ int c; while((c=read())!=-1&&isChar(c)); return c; }
		private byte read() throws IOException{
			if(bufP==bytR){
				bytR=din.read(buffer, bufP=0, 1024);
				if(bytR==-1) buffer[0]=-1;
			}
			return buffer[bufP++];
		}
		public void close() throws IOException{
			if(din==null) return;
			din.close();
		}
	}
}

import java.util.Scanner;
import java.util.StringTokenizer;

public class Round434krounding {
	public static void main(String[] args) {
		Scanner kboard = new Scanner(System.in);

		StringTokenizer token = new StringTokenizer(kboard.nextLine());

		long n = Long.parseLong(token.nextToken());
		int k = Integer.parseInt(token.nextToken());

		int fives = 0, twos = 0;
		while (n % 2 == 0) {
			twos += 1;
			n /= 2;
		}
		while (n % 5 == 0) {
			fives += 1;
			n /= 5;
		}

		long ans = 1;
		for (int i = 0; i < k - fives; i++) {
			ans *= 5;
		}
		for (int i = 0; i < k - twos; i++) {
			ans *= 2;
		}

		System.out.println(ans * n);
	}
}

import java.util.Scanner;

public class Krounding {

	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		double num = Math.pow(10, k);

		if (num < n) {
			System.out.print(n * num);
		} else {

			for (int i = 1;; i++) {
				if ((num * i) % n == 0) {
					System.out.print(num * i);
					break;
				}
			}
		}
		sc.close();
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

//        out.println(1000000000 % Math.pow(10, 8) == 0);
//        long t = 100000000;
//        out.println(t);
            if (k == 0) {
                out.println(n);
                return;
            } else if (n % (long) Math.pow(10, k) == 0) {
                out.println(n);
                return;
            }

            long cnt = 0;
            long reqn = n;
            while (reqn % 5 == 0) {
                ++cnt;
                reqn /= 5;
            }

            long cnt2 = 0;
            long reqN = n;
            while (reqN % 2 == 0) {
                ++cnt2;
                reqN /= 2;
            }

            long cnt10 = 0;
            long req10 = n;
            while (req10 % 10 == 0) {
                ++cnt10;
                req10 /= 10;
            }

            if (cnt > cnt2) {
                cnt -= cnt2;
                n = (long) (Math.pow(2, Math.min(cnt, k)) * n);
                k -= cnt;
                k -= cnt10;
                out.print(n);
                while (k-- > 0)
                    out.print("0");
            } else if (cnt2 > cnt) {
                cnt2 -= cnt;
                n = (long) (Math.pow(5, Math.min(cnt2, k)) * n);
                k -= cnt2;
                k -= cnt10;
                out.print(n);
                while (k-- > 0)
                    out.print("0");
            } else {
                out.print(n);
                k -= cnt10;
                while (k-- > 0) {
                    out.print("0");
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

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

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class bbg
{
	public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static int vizitat[];
public static int x;

	public static void main (String[] args) throws java.lang.Exception
{

Scanner input=new Scanner(System.in);

HashMap<Integer, Integer> contor1= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> contor2= new HashMap<Integer, Integer>();

HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> stop= new HashMap<Integer, Integer>();

		Long n=input.nextLong();
		Long k=input.nextLong();

		if(k==0) System.out.println(n);

		else if (cifrezero(n)>=k) System.out.println(n);

		else{

		int number=0;
			Long rasp=n;
		int x=0;

		for(int i=1;i<=1000;i++)
		{

		    Long prod=n*i*1L;

	//	 System.out.println(i+" "+prod+" ");

		    if(cifrezero(prod)>number && cifrezero(prod)<=k) {rasp=prod; number=cifrezero(prod);}

		  else   if(cifrezero(prod)==number && prod<rasp ) {rasp=prod;
		    number=cifrezero(prod);}

		}

		System.out.print(rasp);

	for(int j=1;j<=k-cifrezero(rasp);j++) System.out.print("0");

		}

		}

		public static int cifrezero(Long nr){

			Long part=nr;
			int contor=0;
			while(part>0l && part%10==0){
				contor++;
				part=part/10l;

			}

			return contor;

		}

		}

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

	public class A861
	{
		public static void main(String[] args)
		{
			InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);

			long n = in.nextLong();
			long k = in.nextLong();
			long p = (long)Math.pow(10, k),temp=n,count=0,t=0;

			while(temp%p!=0)
			{
				while(temp%10==0)
				{
					temp=temp/10;
					t=temp;
					count++;
				}
				pw.println(temp);

				if(temp%5==0)
				{
					temp=temp*2;
				}
				else if(temp%2==0)
				{
					temp=temp*5;
				}
				else
					temp=temp*10;

				temp=temp*(long)Math.pow(10, count);

				pw.println(temp);
			}
			long t1=t;
			while(t%4==0)
			{
				temp=temp/2;
				t=t/2;
			}

			while(t1%25==0)
			{
				temp=temp/5;
				t1=t1/5;
			}

			pw.println(temp);

			pw.flush();
			pw.close();
		}

		static class InputReader
		{

			private final InputStream stream;
			private final byte[] buf = new byte[8192];
			private int curChar, snumChars;
			private SpaceCharFilter filter;

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

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

			public int nextInt()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
			    {
					sgn = -1;
					c = snext();
				}
				int res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

			public long nextLong()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
				{
					sgn = -1;
					c = snext();
				}
				long res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

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

			public String readString()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isSpaceChar(c));
				return res.toString();
			}

			public String nextLine()
			{
				int c = snext();
				while (isSpaceChar(c))
					c = snext();
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isEndOfLine(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;
			}

			private boolean isEndOfLine(int c)
			{
				return c == '\n' || c == '\r' || c == -1;
			}

			public interface SpaceCharFilter
		    {
				public boolean isSpaceChar(int ch);
			}
		}
	}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class bbg
{
	public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static int vizitat[];
public static int x;

	public static void main (String[] args) throws java.lang.Exception
{

Scanner input=new Scanner(System.in);

HashMap<Integer, Integer> contor1= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> contor2= new HashMap<Integer, Integer>();

HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> stop= new HashMap<Integer, Integer>();

		Long n=input.nextLong();
		Long k=input.nextLong();

		if(k==0) System.out.println(n);

		else if (cifrezero(n)>=k) System.out.println(n);

		else{

		int number=0;
			Long rasp=n;
		int x=0;

		for(int i=1;i<=10;i++)
		{

		    Long prod=n*i*1L;

		  //  System.out.println(i+" "+prod+" ");

		    if(cifrezero(prod)>number) {rasp=prod; number=cifrezero(prod);}

		  else   if(cifrezero(prod)==number && prod<rasp ) {rasp=prod;
		    number=cifrezero(prod);}

		}

		System.out.print(rasp);

	for(int j=1;j<=k-cifrezero(rasp);j++) System.out.print("0");

		}

		}

		public static int cifrezero(Long nr){

			Long part=nr;
			int contor=0;
			while(part>0l && part%10==0){
				contor++;
				part=part/10l;

			}

			return contor;

		}

		}

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

public class A {
    public static void main(String[] args){
        new A().run();
    }
    public static void run(){
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        int k = in.nextInt();
        int f = 1;
        while(n % Math.pow(10, k) != 0){
            int t = (int)n / f;
            t = t % 10;
            if(t == 5){
                n *= 2;
            } else if(t == 0){
                f *= 10;
            } else if(t % 2 == 0){
                n *= 5;
            } else {
                n *= 10;
            }
        }
        System.out.println(n);
    }
}

import java.util.*;

public class KRounding {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        long c = (long) Math.pow(10, k);
        long d = c;
        long a = 1;
        int b = 0;
        String p = String.valueOf(n);
        long e = 0;
        for (long i = c; i <= d * n;) {
            if (i % n == 0) {
                a = i;
                break;
            }
            long r = (long) p.charAt(b) - '0';
            e = 10 * e + r;
            i = c * e;
            b++;
        }
        System.out.println(a);
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
public class cf
{
    static int n;
    static int k;
    static String s;
    static int arr[];
    public static void main(String args[])throws IOException
    {
        PrintWriter out=new PrintWriter(System.out);
        Scanner sc=new Scanner(System.in);
        long n=sc.nextLong();
        int k=sc.nextInt();
        long temp=0;
        long arr[]=new long[1000];
        int maxzerocount=0;
        for(int i =1;i<=1000;i++)
        {
            long num=(long)n*(long)i;
            arr[i-1]=num;
            if(num%(long)Math.pow(10,k)==0)
            {
                System.out.println(num);
                System.exit(0);
            }
            temp=num;
            int count=0;
            while(temp!=0)
            {
                if(temp%10==0)
                count++;
                else break;
                temp/=10;
            }
            maxzerocount=Math.max(maxzerocount,count);
        }
        for(int i = 0 ;i<1000;i++)
        {
            temp=arr[i];
            int count=0;
            while(temp!=0)
            {
                if(temp%10==0)
                count++;
                else break;
                temp/=10;
            }
            if(count==maxzerocount)
            {
                System.out.print(arr[i]);
                for(int l=0;l<k-maxzerocount;l++)
                System.out.print("0");
                System.exit(0);
            }
        }
    }
}

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

public class A858 {
	public static void main(String args[])throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer str = new StringTokenizer(br.readLine());
		long n = Integer.parseInt(str.nextToken());
		int k = Integer.parseInt(str.nextToken());
		int numTwos = numPowers(n, 2);
		int numFives = numPowers(n, 5);
		int min = Math.min(numTwos, numFives);
		if(min >= k) {
			System.out.println(n);
			return;
		}
		k-=min;
		numFives -= min;
		numTwos -= min;
		if(Math.max(numFives, numTwos) >= k) {
			if(numFives >numTwos) {
				System.out.println(n* Math.pow(2, k));
				return;
			}
			else {
				System.out.println(n* Math.pow(5, k));
				return;
			}
		} else {
			long aux = 1;
			while(k>0) {
				if(numTwos >0) {
					numTwos --;
					k--;
					aux*=5;
				}
				else if(numFives >0) {
					numFives --;
					k--;
					aux*=2;
				}
				else {
					k--;
					aux*=10;
				}
			}
			System.out.println(n*aux);
		}
	}
	public static int numPowers(long n, int x) {
		int result =0;
		while(n>0 && n%x ==0) {
			n/=x;
			result++;
		}
		return result;
	}
}

import java.util.Scanner;

public class KRounding{
	public static void main (String[] args) {
		Scanner kbd = new Scanner(System.in);
		long x, y;

		x = kbd.nextLong();
		y = kbd.nextLong();
		for(long i = 0; i < y; i++){
			if(x % 2 == 0){
				x/= 2;
			}
			if(x % 5 == 0){
				x/= 5;
			}
		}
		System.out.println((int)x);

		for(long i = 0; i < y; i++){
			System.out.print("0");
		}

	}
}

import java.util.*;
import java.io.*;
import java.lang.Math;

public class main{
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		long n = s.nextLong();
		int k = s.nextInt();
		int divisor = (int)Math.pow(10,k);
		if(k==0) System.out.println(n);
		else if(n%divisor==0) System.out.println(n);
	else{
		int increment =0;
		if(n%5==0) increment = 2;
		else if(n%2!=0) increment = 10;
		else increment = 5;
		for(int i=increment;i<=divisor;i+=increment){
			if((n*i)%divisor==0) {System.out.println(n*i);
			break;}
		}
	}
	}
}

//package com.company;
import java.util.*;
import java.io.*;
public class Main {
    public static long gcd(long p, long q) {
        if (q == 0) return p;
        return gcd(q, p % q);
    }
    private static long lcm(long a, long b)
    {
        return a * (b / gcd(a, b));
    }
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        long n = in.nextInt();
        long k = in.nextInt();

        k = 10 * (k+1);
        out.println(lcm(n,k)+ "000000000000000");

        out.flush();
    }
}

import java.io.*;
import java.util.*;
public class kRounding
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        String s=String.valueOf(n);
        for(int i=0;i<k;i++)
            s=s+"0";
        System.out.println(s);
    }
}

import java.util.*;

public class X
{

public static void main (String[] args)
	{

	 Scanner  s=new Scanner(System.in);
     long n=s.nextLong();
     int k=s.nextInt();
     int pow=(int)Math.pow(10,k);
     for(int i=1;i<=pow;i++){
    	 long temp=n*i;
    	 if(temp%k==0){
    		 System.out.println(temp);break;}
     }

	 s.close();
	}

}

import java.util.Scanner;

public class KRound {

    static Scanner sc = new Scanner(System.in);
    public static void main(String... args) {
        int n = sc.nextInt(), k = sc.nextInt();
        int t = 1;
        while (!checkForZeros(n * t, k)) {
            t++;
        }
        System.out.println(n * t);
    }

    public static boolean checkForZeros(int a, int k) {
        return a % power(10, k) == 0;
    }

    private static int power(int n, int p) {
        int res = 1;
        for (int i = 0; i < p; i++)
            res *= n;
        return res;
    }

}

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

	public class A861
	{
		public static void main(String[] args)
		{
			InputReader in = new InputReader(System.in);
			PrintWriter pw = new PrintWriter(System.out);

			long n = in.nextLong();
			long k = in.nextLong();
			long ans=n,p=(long)Math.pow(10, k);

			for(int i=0;i<k;i++)
			{
				if(n%p==0)
					break;
				if(n%5==0)
				{
					ans=ans*2;
					n=n/5;
				}

				else if(n%2==0)
				{
					ans=ans*5;
					n=n/3;
				}
				else
					ans=ans*10;
			}

			pw.println(ans);

			pw.flush();
			pw.close();
		}

		static class InputReader
		{

			private final InputStream stream;
			private final byte[] buf = new byte[8192];
			private int curChar, snumChars;
			private SpaceCharFilter filter;

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

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

			public int nextInt()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
			    {
					sgn = -1;
					c = snext();
				}
				int res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

			public long nextLong()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				int sgn = 1;
				if (c == '-')
				{
					sgn = -1;
					c = snext();
				}
				long res = 0;
				do
				{
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					res *= 10;
					res += c - '0';
					c = snext();
				} while (!isSpaceChar(c));
				return res * sgn;
			}

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

			public String readString()
		    {
				int c = snext();
				while (isSpaceChar(c))
				{
					c = snext();
				}
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isSpaceChar(c));
				return res.toString();
			}

			public String nextLine()
			{
				int c = snext();
				while (isSpaceChar(c))
					c = snext();
				StringBuilder res = new StringBuilder();
				do
				{
					res.appendCodePoint(c);
					c = snext();
				} while (!isEndOfLine(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;
			}

			private boolean isEndOfLine(int c)
			{
				return c == '\n' || c == '\r' || c == -1;
			}

			public interface SpaceCharFilter
		    {
				public boolean isSpaceChar(int ch);
			}
		}
	}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

            if (k == 0) {
                out.println(n);
                return;
            } else if (n % (long) Math.pow(10, k) == 0) {
                out.println(n);
                return;
            }

            long cnt = 0;
            long reqn = n;
            while (reqn % 5 == 0) {
                ++cnt;
                reqn /= 5;
            }

            long cnt2 = 0;
            long reqN = n;
            while (reqN % 2 == 0) {
                ++cnt2;
                reqN /= 2;
            }

            long cnt10 = 0;
            long req10 = n;
            while (req10 % 10 == 0) {
                ++cnt10;
                req10 /= 10;
            }

            if (cnt > cnt2) {
                cnt -= cnt2;
                n = (long) (Math.pow(2, cnt) * n);
                k -= cnt;
                out.print(n);
                while (k-- > 0)
                    out.print("0");
            } else if (cnt2 > cnt) {
                cnt2 -= cnt;
                n = (long) (Math.pow(5, cnt2) * n);
                k -= cnt2;
                out.print(n);
                while (k-- > 0)
                    out.print("0");
            } else {
                out.print(n);
                k -= cnt10;
                while (k-- > 0) {
                    out.print("0");
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

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

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class First {
    private static final Scanner sc = new Scanner(System.in);
    private static final PrintWriter pw = new PrintWriter(System.out);
    private static StringBuffer ans = new StringBuffer();

    public static void main(String[] args) throws Exception {
        long n = sc.nextLong(), k = sc.nextLong(), mod = 1;
        for (int i = 0; i < k; i++) mod *= 10L;
        if (k == 0L) k++;
        for (long i = k; ; i += k) {
            if ((n * i) % mod == 0) {
                ans.append(n * i);
                break;
            }
        }
        pw.print(ans);
        sc.close();
        pw.close();
    }

}

class Scanner {
    private final BufferedReader br;
    private StringTokenizer st;

    public Scanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
        st = new StringTokenizer("");
    }

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

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

    public void close() throws IOException {
        br.close();
    }
}

class PrintWriter {
    private final BufferedOutputStream pw;

    public PrintWriter(OutputStream out) {
        pw = new BufferedOutputStream(out);
    }

    public void print(Object o) throws IOException {
        pw.write(o.toString().trim().getBytes());
        pw.flush();
    }

    public void close() throws IOException {
        pw.close();
    }
}

import java.util.*;
import java.io.*;
public class Main
{

	static ArrayList<Integer> adj[];
	static char color[];
	static boolean b[],visited[],possible;
	static Map<Integer,HashSet<Integer>> s;
	static int totalnodes,colored;
	static int count[];
	static long sum[];
	static double ans=0;
	static long[] as=new long[10001];
	public static void main(String[] args) throws IOException
	{
		in=new InputReader(System.in);
		w=new PrintWriter(System.out);
		int n=in.nextInt(),k=in.nextInt();
     w.print(Solution(n,k));

   w.close();
		}
	public static long Solution(int n,int k)
	{
	long ans=n;
     long rounding=(long)Math.pow(10,k),s=0;
	if(k==0)
	return n;
	for(int i=1;i<=10;i++)
	{
	long temp=(long)n*i;
	if(temp%10==0)
	{
	ans=Solution((int)temp/10,k-1)*10;
	break;
	}
	}
	return ans;
	}
	public static String rev(String s)
	{
		StringBuilder sb=new StringBuilder(s);
		sb.reverse();
		return sb.toString();
	}

	static InputReader in;
	static PrintWriter w;
static class InputReader
{

private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
private SpaceCharFilter filter;

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

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

public int nextInt()
{
  int c = snext();
  while (isSpaceChar(c))
  {
    c = snext();
  }
  int sgn = 1;
  if (c == '-')
  {
    sgn = -1;
    c = snext();
  }
  int res = 0;
  do
  {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  }
  while (!isSpaceChar(c));
  return res * sgn;
}

public long nextLong()
{
  int c = snext();
  while (isSpaceChar(c))
  {
    c = snext();
  }
  int sgn = 1;
  if (c == '-')
  {
    sgn = -1;
    c = snext();
  }
  long res = 0;
  do
  {
    if (c < '0' || c > '9')
      throw new InputMismatchException();
    res *= 10;
    res += c - '0';
    c = snext();
  }
  while (!isSpaceChar(c));
  return res * sgn;
}

public int[] nextIntArray(int n)
{
	 return nextIntArray(n, 0);
	    }

public int[] nextIntArray(int n, int off)
{
	 int[] arr = new int[n + off];
	   for (int i = 0; i < n; i++)
	   {
	    arr[i + off] = nextInt();
	    }
	    return arr;
	    }

public long[] nextLongArray(int n)
{
return nextLongArray(n, 0);
	    }

	public long[] nextLongArray(int n, int off)
	{
	 long[] arr = new long[n + off];
	 for (int i = 0; i < n; i++)
	 {
		  arr[i + off] = nextLong();
		 }
 return arr;
	}

public String readString()
{
  int c = snext();
  while (isSpaceChar(c))
  {
    c = snext();
  }
  StringBuilder res = new StringBuilder();
  do
  {
    res.appendCodePoint(c);
    c = snext();
  }
  while (!isSpaceChar(c));
  return res.toString();
}

public String nextLine()
{
  int c = snext();
  while (isSpaceChar(c))
    c = snext();
  StringBuilder res = new StringBuilder();
  do
  {
    res.appendCodePoint(c);
    c = snext();
  }
  while (!isEndOfLine(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;
}

private boolean isEndOfLine(int c)
{
  return c == '\n' || c == '\r' || c == -1;
}

public interface SpaceCharFilter
{
  public boolean isSpaceChar(int ch);
}
}

}

import java.util.Scanner;

public class kRounding {

    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        long n, k, ans;

        n = reader.nextLong();
        k = reader.nextLong();

        long num2 = 0;
        long num5 = 0;
        long num0 = 0;
        ans = n;

        long temp = n;
        while (temp % 10 == 0) {
            num0++;
            temp /= 10;
        }

        temp = n;
        while (temp % 2 == 0) {
            num2++;
            temp /= 2;
        }

        temp = n;
        while (temp % 5 == 0) {
            num5++;
            temp /= 5;
        }

        if (num2 > num5) {
            for (int i = 0; i < (num2 - num5); i++) {
                ans *= 5;
                num0++;
                if (num0 == k) {
                    System.out.println(ans);
                    System.exit(0);
                }
            }
        } else if (num5 > num2) {
            for (int i = 0; i < (num5 - num2); i++) {
                ans *= 2;
                num0++;
                if (num0 == k) {
                    System.out.println(ans);
                    System.exit(0);
                }
            }
        }

        while (num0 < k) {
            ans *= 10;
            num0++;
        }

        System.out.println(ans);
        System.exit(0);
    }
}

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

public class Main {

	public static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public char nextChar() {
			return next().charAt(0);
		}

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

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

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

		public int[] nextIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			return arr;
		}

		public Integer[] nextIntegerArr(int n) {
			Integer[] arr = new Integer[n];
			for (int i = 0; i < n; i++) {
				arr[i] = new Integer(this.nextInt());
			}
			return arr;
		}

		public int[][] next2DIntArr(int n, int m) {
			int[][] arr = new int[n][m];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < m; j++) {
					arr[i][j] = this.nextInt();
				}
			}
			return arr;
		}

		public int[] nextSortedIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			Arrays.sort(arr);
			return arr;
		}

		public long[] nextLongArr(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextLong();
			}
			return arr;
		}

		public char[] nextCharArr(int n) {
			char[] arr = new char[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextChar();
			}
			return arr;
		}
	}

	public static InputReader scn = new InputReader();
	public static PrintWriter out = new PrintWriter(System.out);

	public static ArrayList<Integer>[] list;

	public static void main(String[] args) {
		// InputStream inputStream = System.in; // Useful when taking input other than
		// console eg file handling // check ctor of inputReader

		int n = scn.nextInt(), k = scn.nextInt();
		int t = 0, f = 0, nn = n;
		while(n % 2 == 0) {
			t++;
			n /= 2;
		}
		while(n % 5 == 0) {
			f++;
			n /= 5;
		}

		int m = Math.min(f, t);
		long ans = n * (long)Math.pow(10, m);
		f -= m;
		t -= m;

		ans = ans * (long)Math.pow(10, Math.max(f, t));
		while(ans % 10 == 0) {
			ans /= 10;
		}

		ans = ans * (long)Math.pow(10, k);
		ans = Math.max(ans, nn);
		System.out.println(ans % nn == 0 ? ans : 0 / 0);
		out.close();
	}
}

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

public class Main {

	public static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public char nextChar() {
			return next().charAt(0);
		}

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

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

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

		public int[] nextIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			return arr;
		}

		public Integer[] nextIntegerArr(int n) {
			Integer[] arr = new Integer[n];
			for (int i = 0; i < n; i++) {
				arr[i] = new Integer(this.nextInt());
			}
			return arr;
		}

		public int[][] next2DIntArr(int n, int m) {
			int[][] arr = new int[n][m];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < m; j++) {
					arr[i][j] = this.nextInt();
				}
			}
			return arr;
		}

		public int[] nextSortedIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			Arrays.sort(arr);
			return arr;
		}

		public long[] nextLongArr(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextLong();
			}
			return arr;
		}

		public char[] nextCharArr(int n) {
			char[] arr = new char[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextChar();
			}
			return arr;
		}
	}

	public static InputReader scn = new InputReader();
	public static PrintWriter out = new PrintWriter(System.out);

	public static ArrayList<Integer>[] list;

	public static void main(String[] args) {
		// InputStream inputStream = System.in; // Useful when taking input other than
		// console eg file handling // check ctor of inputReader

		int n = scn.nextInt(), k = scn.nextInt();
		int t = 0, f = 0, nn = n;
		while(n % 2 == 0) {
			t++;
			n /= 2;
		}
		while(n % 5 == 0) {
			f++;
			n /= 5;
		}

		int m = Math.min(f, t);
		long ans = n * (long)Math.pow(10, m);
		f -= m;
		t -= m;

		ans = ans * (long)Math.pow(10, Math.max(f, t));
		while(ans % 10 == 0) {
			ans /= 10;
		}

		ans = ans * (long)Math.pow(10, k);
		System.out.println(Math.max(ans, nn));
		out.close();
	}
}

import java.util.*;
import java.io.*;
public class b{
	static int cnt(long n){
		int cnt=0;
		while(n%10==0){
			cnt++;
			n=n/10;
		}
		return cnt;
	}
	public static void main(String [] args){
		Scanner sc=new Scanner(System.in);
		long n=sc.nextInt();
		long k=sc.nextInt();
		long m=n;
		int cnt5=0,cnt2=0;

		if(cnt(n)>=k){
			System.out.println(n);
			return;
		}

		while(m>0 && m%5==0){
			cnt5++;
			m=m/5;
		}
		while(m>0 && m%2==0){
			cnt2++;
			m=m/2;
		}

		// System.out.println(cnt2+" "+cnt5);

		int zero=Math.min(cnt2,cnt5);

		k=k-zero;

		long ans=(long)Math.pow(2,k-cnt2)*(long)Math.pow(5,k-cnt5)*n;
		System.out.println(ans);

	}
}

import java.util.Scanner;
import java.util.StringTokenizer;

public class Round434krounding {
	public static void main(String[] args) {
		Scanner kboard = new Scanner(System.in);

		StringTokenizer token = new StringTokenizer(kboard.nextLine());

		long n = Long.parseLong(token.nextToken());
		int k = Integer.parseInt(token.nextToken());

		long orig = n;

		int fives = 0, twos = 0;
		while (n % 2 == 0) {
			twos += 1;
			n /= 2;
		}
		while (n % 5 == 0) {
			fives += 1;
			n /= 5;
		}

		System.out.println(fives + " " + twos);

		long ans = 1;
		for (int i = 0; i < k - fives; i++) {
			ans *= 5;
		}
		for (int i = 0; i < k - twos; i++) {
			ans *= 2;
		}

		System.out.println(ans * orig);
	}
}

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

public class Main {
    static String mul(String s, int k){
        StringBuilder f = new StringBuilder();
        for (int i = 0; i < k; i++) {
            f.append(s);
        }
        return f.toString();
    }

    static String last(String s, int k){
        StringBuilder sb = new StringBuilder();
        for (int i = s.length() - k; i < s.length(); i++) {
            sb.append(s.charAt(i));
        }
        return sb.toString();
    }
    public static void main(String args[]) throws Exception {
        init("in.txt", "out.txt");
        long n = nextLong();
        int k = nextInt();

        String need = mul("0", k);

        long f = n % 10;
        if (f == 3 || f == 6 || f == 7 || f == 9){
            out.println(n + need);
            out.close();
            return;
        }
        long i = 0;
        while (true){
            i++;
            long t = n * i;
            if ((t + "").length() < need.length())
                continue;
            if (last(t + "", k).equals(need)){
                out.println(t);
                break;
            }

        }
        out.close();
    }

    static BufferedReader scan;
    static PrintWriter out;
    static StringTokenizer st;

    static void init() {
        scan = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    static void init(String name1, String name2) throws Exception {
        try {
            scan = new BufferedReader(new FileReader(name1));
            out = new PrintWriter(name2);
        } catch (Exception e) {
            scan = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    static String next() throws Exception {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(scan.readLine());
        return st.nextToken();
    }

    static int nextInt() throws Exception {
        return Integer.parseInt(next());
    }

    static long nextLong() throws Exception {
        return Long.parseLong(next());
    }
}

import java.io.*;
import java.util.*;
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
import java.lang.*;
public class Solution{

	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		long n = in.nextLong();
		long m = in.nextLong();
		long ans = 0;
		long index = 0;
		long temp = m;
		while(temp>0){
		    if(index==0){
		        index++;
		    }
		    else{
		        index*=10;
		    }
		    temp--;
		}
		index*=10;
		long index2 = index;
		if(m==0 || m == 1){
		    System.out.println(n);
		}
		else{
		    ans = lcm(n,index);
		    System.out.println(ans);
		}
	}
	public static long lcm(long a, long b){
	    return a * b / gcd(a,b);
	}
	public static long gcd(long a, long b){
	    if(b==0){
	        return a;
	    }
	    return gcd(b, a%b);
	}
}

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

public class Main {
    public static void main (String[] args) throws java.lang.Exception {
        Output out = new Output();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken()),
            k = Integer.parseInt(st.nextToken());

        int current_zeros = 0;
        for (int i=1 ; i<=9 ; i++) {
            if (n%(int)Math.pow(10, i) != 0) break;
            current_zeros++;
        }

        long rounded = n;
        while (current_zeros < k) {
            rounded *= 10;
            current_zeros++;
        }
        out.println(rounded);
        out.flush();
    }

}

class Output {
    private BufferedWriter out;

    Output() {
        this.out = new BufferedWriter(new OutputStreamWriter(System.out));
    }

    void print(String s) throws IOException {this.out.write(s);}
    void println(String s) throws IOException {this.out.write(s + "\n");}
    void println(long n) throws IOException {this.out.write(n + "\n");}
    void println(int n) throws IOException {this.out.write(n + "\n");}
    void flush () throws IOException {this.out.flush();}
}

import java.util.Scanner;

public class KRounding{
	public static void main (String[] args) {
		Scanner kbd = new Scanner(System.in);
		long x, y;

		x = kbd.nextLong();
		y = kbd.nextLong();
		for(long i = 0; i < y; i++){
			if(x % 2 == 0){
				x/= 2;
			}
			if(x % 5 == 0){
				x/= 5;
			}
		}
		System.out.println((int)x);

		for(long i = 0; i < y; i++){
			System.out.print("0");
		}

	}
}

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

public class Main {

	public static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public char nextChar() {
			return next().charAt(0);
		}

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

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

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

		public int[] nextIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			return arr;
		}

		public Integer[] nextIntegerArr(int n) {
			Integer[] arr = new Integer[n];
			for (int i = 0; i < n; i++) {
				arr[i] = new Integer(this.nextInt());
			}
			return arr;
		}

		public int[][] next2DIntArr(int n, int m) {
			int[][] arr = new int[n][m];
			for (int i = 0; i < n; i++) {
				for (int j = 0; j < m; j++) {
					arr[i][j] = this.nextInt();
				}
			}
			return arr;
		}

		public int[] nextSortedIntArr(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextInt();
			}
			Arrays.sort(arr);
			return arr;
		}

		public long[] nextLongArr(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextLong();
			}
			return arr;
		}

		public char[] nextCharArr(int n) {
			char[] arr = new char[n];
			for (int i = 0; i < n; i++) {
				arr[i] = this.nextChar();
			}
			return arr;
		}
	}

	public static InputReader scn = new InputReader();
	public static PrintWriter out = new PrintWriter(System.out);

	public static ArrayList<Integer>[] list;

	public static void main(String[] args) {
		// InputStream inputStream = System.in; // Useful when taking input other than
		// console eg file handling // check ctor of inputReader

		String s1 = scn.next();
		int s2 = scn.nextInt();
		String s3 = "";
		for(int i = 0; i < s2; i++) {
			s3 += '0';
		}
		System.out.println(s1 + s3);
		out.close();
	}
}

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

public class A {
    public static void main(String[] args){
        new A().run();
    }
    public static void run(){
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        int k = in.nextInt();
        int f = 1;
        while(n % Math.pow(10, k) != 0){
            int t = (int)n / f;
            t = t % 10;
            if(t == 2 || t == 5){
                n *= (int)(10 / t);
            } else if(t == 0){
                f += 1;
            } else{
                n *= 10;
            }
        }
        System.out.println(n);
    }
}

    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.*;

    public class Main
    {
        static class Reader
        {
            final private int BUFFER_SIZE = 1 << 16;
            private DataInputStream din;
            private byte[] buffer;
            private int bufferPointer, bytesRead;

            public Reader()
            {
                din = new DataInputStream(System.in);
                buffer = new byte[BUFFER_SIZE];
                bufferPointer = bytesRead = 0;
            }

            public Reader(String file_name) throws IOException
            {
                din = new DataInputStream(new FileInputStream(file_name));
                buffer = new byte[BUFFER_SIZE];
                bufferPointer = bytesRead = 0;
            }

            public String readLine() throws IOException
            {
                byte[] buf = new byte[64]; // line length
                int cnt = 0, c;
                while ((c = read()) != -1)
                {
                    if (c == '\n')
                        break;
                    buf[cnt++] = (byte) c;
                }
                return new String(buf, 0, cnt);
            }

            public int nextInt() throws IOException
            {
                int ret = 0;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();
                do
                {
                    ret = ret * 10 + c - '0';
                }  while ((c = read()) >= '0' && c <= '9');

                if (neg)
                    return -ret;
                return ret;
            }

            public long nextLong() throws IOException
            {
                long ret = 0;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();
                do {
                    ret = ret * 10 + c - '0';
                }
                while ((c = read()) >= '0' && c <= '9');
                if (neg)
                    return -ret;
                return ret;
            }

            public double nextDouble() throws IOException
            {
                double ret = 0, div = 1;
                byte c = read();
                while (c <= ' ')
                    c = read();
                boolean neg = (c == '-');
                if (neg)
                    c = read();

                do {
                    ret = ret * 10 + c - '0';
                }
                while ((c = read()) >= '0' && c <= '9');

                if (c == '.')
                {
                    while ((c = read()) >= '0' && c <= '9')
                    {
                        ret += (c - '0') / (div *= 10);
                    }
                }

                if (neg)
                    return -ret;
                return ret;
            }

            private void fillBuffer() throws IOException
            {
                bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
                if (bytesRead == -1)
                    buffer[0] = -1;
            }

            private byte read() throws IOException
            {
                if (bufferPointer == bytesRead)
                    fillBuffer();
                return buffer[bufferPointer++];
            }

            public void close() throws IOException
            {
                if (din == null)
                    return;
                din.close();
            }
        }
        public static void main(String[] args) throws IOException {

            Reader s = new Reader();

            long n = s.nextLong();
            int k = s.nextInt();

            int num5 = 0;
            int num2 = 0;

            while (n % 5 == 0) {
                n /= 5;
                num5++;
            }
            while (n % 2 == 0) {
                n /= 2;
                num2++;
            }

            System.out.println((int) Math.pow(2, Math.max(k - num2, 0)) * (int) Math.pow(5, Math.max(k - num5, 0)));

            }
    }

import java.util.Scanner;

public class Krounding1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int k = input.nextInt();
	if(gcd(n,(int)Math.pow(10,k))==1){System.out.print(Integer.toString(n));for(int i=0;i<k;i++)System.out.print("0");}
	else
		System.out.println(lcm(n,(int)Math.pow(10,k)));
		//System.out.println(gcd(n,(int)Math.pow(10,k)));
	}

	private static long gcd(int a, int b){
		if(b==0)return a;
		else
			return gcd(b,a%b);
	}
	private static long lcm(int a, int b){
		return (a*b)/gcd(a,b);
	}

}

import java.io.*;
import java.util.*;
public class kRounding
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        String s=String.valueOf(n);
        for(int i=0;i<k;i++)
            s=s+"0";
        System.out.println(s);
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
public class cf
{
    static int n;
    static int k;
    static String s;
    static int arr[];
    public static void main(String args[])throws IOException
    {
        PrintWriter out=new PrintWriter(System.out);
        Scanner sc=new Scanner(System.in);
        long n=sc.nextLong();
        int k=sc.nextInt();
        long temp=0;
        long arr[]=new long[10];
        int maxzerocount=0;
        for(int i =1;i<=10;i++)
        {
            long num=(long)n*(long)i;
            arr[i-1]=num;
            if(num%(long)Math.pow(10,k)==0)
            {
                System.out.println(num);
                System.exit(0);
            }
            temp=num;
            int count=0;
            while(temp!=0)
            {
                if(temp%10==0)
                count++;
                else break;
                temp/=10;
            }
            maxzerocount=Math.max(maxzerocount,count);
        }
        for(int i = 0 ;i<10;i++)
        {
            temp=arr[i];
            int count=0;
            while(temp!=0)
            {
                if(temp%10==0)
                count++;
                else break;
                temp/=10;
            }
            if(count==maxzerocount)
            {
                System.out.print(arr[i]);
                for(int l=0;l<k-maxzerocount;l++)
                System.out.print("0");
                System.exit(0);
            }
        }
    }
}

import java.util.*;

public class Main {

	public static void main (String args[]){

		Scanner in = new Scanner (System.in);

		String s = in.next();
		int k = in.nextInt();

		int cnt = 0;
		for(int i=s.length()-1; s.charAt(i)=='0'; i--) cnt++;

		cnt = Math.max(0,k-cnt);

		System.out.printf("%s",s);
		for(int i=0; i<cnt; i++)System.out.printf("%c",'0');

	}

}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class bbg
{
	public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static int vizitat[];
public static int x;

	public static void main (String[] args) throws java.lang.Exception
{

Scanner input=new Scanner(System.in);

HashMap<Integer, Integer> contor1= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> contor2= new HashMap<Integer, Integer>();

HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> stop= new HashMap<Integer, Integer>();

		Long n=input.nextLong();
		Long k=input.nextLong();

		if(k==0) System.out.println(n);

		else if (cifrezero(n)>=k) System.out.println(n);

		else{

		int number=0;
			Long rasp=n;
		int x=0;

		for(int i=1;i<=100;i++)
		{

		    Long prod=n*i*1L;

		//  System.out.println(i+" "+prod+" ");

		    if(cifrezero(prod)>number && cifrezero(prod)<=k) {rasp=prod; number=cifrezero(prod);}

		  else   if(cifrezero(prod)==number && prod<rasp ) {rasp=prod;
		    number=cifrezero(prod);}

		}

		System.out.print(rasp);

	for(int j=1;j<=k-cifrezero(rasp);j++) System.out.print("0");

		}

		}

		public static int cifrezero(Long nr){

			Long part=nr;
			int contor=0;
			while(part>0l && part%10==0){
				contor++;
				part=part/10l;

			}

			return contor;

		}

		}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
import java.math.BigInteger;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Ocykat
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Prob861A solver = new Prob861A();
        solver.solve(1, in, out);
        out.close();
    }

    static class Prob861A {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long rn = in.nextLong();
            int k = in.nextInt();
            if (k == 0) {
                out.println(rn);
                return;
            }
            BigInteger n = new BigInteger(Long.toString(rn));
            BigInteger nn = n;
            int pnZeros = numberOfZero(n);
            int nnZeros = pnZeros;
            int cnt = 2;
            while ((nnZeros < k)) {
                nn = n.multiply(BigInteger.valueOf(cnt));
                nnZeros = numberOfZero(nn);
                if (pnZeros != nnZeros) {
                    cnt = 0;
                    n = nn;
                }
                pnZeros = nnZeros;
                cnt += 2;
            }
            out.println(nn);
            return;
        }

        private int numberOfZero(BigInteger n) {
            int res = 0;
            while (n.mod(BigInteger.TEN).equals(BigInteger.ZERO)) {
                n = n.divide(BigInteger.TEN);
                res++;
            }
            return res;
        }

    }
}

import java.util.Scanner;

public class Krounding {

	public static void main(String args[]) {
			Scanner sc = new Scanner(System.in);
			long n = sc.nextLong();
			long k = sc.nextLong();
			long num = (long) Math.pow(10, k);
			long answer = 0;
			if (k == 0) {
				answer = n;
			} else if (num < n && k > 1) {
				answer = n * num;
			} else {
				long m = num;
				while (true) {
					if (m % n == 0) {
						answer = m;
						break;
					} else {
						m += num;
					}
				}
			}
			System.out.println(answer);
			sc.close();
	}
}

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

public class A858 {
	public static void main(String args[])throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer str = new StringTokenizer(br.readLine());
		long n = Integer.parseInt(str.nextToken());
		int k = Integer.parseInt(str.nextToken());
		int numTwos = numPowers(n, 2);
		int numFives = numPowers(n, 5);
		int min = Math.min(numTwos, numFives);
		if(min >= k) {
			System.out.println(n);
			return;
		}
		k-=min;
		numFives -= min;
		numTwos -= min;
		if(Math.max(numFives, numTwos) >= k) {
			if(numFives >numTwos) {
				System.out.println(n* Math.pow(2, k));
				return;
			}
			else {
				System.out.println(n* Math.pow(5, k));
				return;
			}
		} else {
			long aux = 1;
			while(k>0) {
				if(numTwos >0) {
					numTwos --;
					k--;
					aux*=5;
				}
				else if(numFives >0) {
					numFives --;
					k--;
					aux*=2;
				}
				else {
					k--;
					aux*=10;
				}
			}
			System.out.println(n*aux);
		}
	}
	public static int numPowers(long n, int x) {
		int result =0;
		while(n>0 && n%x ==0) {
			n/=x;
			result++;
		}
		return result;
	}
}

import java.util.*;

public class KRounding {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        long c = (long) Math.pow(10, k);
        long d = c;
        long a = 1;
        int b = 0;
        String p = String.valueOf(n);
        long e = 0;
        for (long i = c; i <= d * n;) {
            if (i % n == 0) {
                a = i;
                break;
            }
            long r = (long) p.charAt(b) - '0';
            e = 10 * e + r;
            i = c * e;
            b++;
        }
        System.out.println(a);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            long k = in.nextLong();

//        out.println(1000000000 % Math.pow(10, 8) == 0);
//        long t = 100000000;
//        out.println(t);
            if (k == 0) {
                out.println(n);
                return;
            } else if (n % (long) Math.pow(10, k) == 0) {
                out.println(n);
                return;
            }

            long cnt = 0;
            long reqn = n;
            while (reqn % 5 == 0) {
                ++cnt;
                reqn /= 5;
            }

            long cnt2 = 0;
            long reqN = n;
            while (reqN % 2 == 0) {
                ++cnt2;
                reqN /= 2;
            }

            long cnt10 = 0;
            long req10 = n;
            while (req10 % 10 == 0) {
                ++cnt10;
                req10 /= 10;
            }

            if (cnt > cnt2) {
                cnt -= cnt2;
                n = (long) (Math.pow(2, cnt) * n);
                k -= cnt;
                k -= cnt10;
                out.print(n);
                while (k-- > 0)
                    out.print("0");
            } else if (cnt2 > cnt) {
                cnt2 -= cnt;
                n = (long) (Math.pow(5, cnt2) * n);
                k -= cnt2;
                k -= cnt10;
                out.print(n);
                while (k-- > 0)
                    out.print("0");
            } else {
                out.print(n);
                k -= cnt10;
                while (k-- > 0) {
                    out.print("0");
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

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

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

//package competitive;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Vector;
public class A861 {
	/*public static long gcd (long a,long b)
	{
		if(b==0)
			return a;
		return gcd(b,a%b);
	}
	public static long bs(long l,long r,long val,long n)
	{ long mid,ans;
		long temp;

		if(l<r)
		{
			mid=(l+r)/2;
			temp=mid*n;
			if(temp%val==0)
				{r=mid-1;ans=mid;}
			else
			{

			}
		}

	}*/
	public static void main(String args[])throws IOException
	{
		BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
		String s=br.readLine();
		String str[]=s.trim().split(" ");
		long n=Long.parseLong(str[0]);
		long k=Long.parseLong(str[1]);
		long val=1,i;
		for( i=0;i<k;++i)
		{
			val*=10;
		}
		/*long temp=n,c=0;
		while(temp%10==0 && temp>0)
		{++c;temp/=10;
		}
		temp=1;
		for(i=0;i<k-c;++i)
		{
		temp*=10;
		}*/

		//long r=temp;
		long ans=n,temp;
		long l=ans%10;;
		//System.out.println(l+" "+r+" "+ans+" "+val+" "+n);

		if((ans%val)!=0)
		{
			if(l!=0 && l%2==0)
				ans*=5;
			else if(l!=0 && l%2==1 && l!=5)
				ans*=10;
			else if(l==5)
				ans*=2;
		}
		if(ans%val==0)
		{System.out.print(ans);return;}
		long r=val/1000000;
		//System.out.println("anss"+ans);
		while(r>0 && ans%r!=0)
		{
			ans*=10;
		}
		//System.out.println(ans+" "+r);
		for(i=2;i<=1000000;++i)
		{	temp=ans*i;
			if(temp%val==0)
				{ans=temp;break;}
		}

		System.out.println(ans);
	}

}

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.util.StringTokenizer;

public class A {

	public static int zeroes (long n) {
		int res = 0;
		while(n % 10 == 0 && n != 0) {
			n /= 10;
			res++;
		}
		return res;
	}

	public static void main(String[] args) throws IOException {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int k = in.nextInt();

		if(k == 0){
			System.out.println(n);
			return;
		}

		int max = 0;
		int I = 1;

		for (int i = 1; i <= 10; i++) {
			long cur = ((long) i) * n;
			int z = zeroes(cur);
			if(z > max) {
				I = i;
				max = z;
			}
//			System.out.println(cur + " " + z);
		}

		int rem = k - max;
		System.out.print(((long) I) * n);
		for (int i = 0; i < rem; i++) {
			System.out.print(0);
		}
	}

	private static class Scanner
	{
		StringTokenizer st;
		BufferedReader br;

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

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

		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
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if(x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for(int i = start; i < x.length(); i++)
				if(x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				}
				else
				{
					sb.append(x.charAt(i));
					if(dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg?-1:1);
		}

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

		public void waitForInput(long time)
		{
			long ct = System.currentTimeMillis();
			while(System.currentTimeMillis() - ct < time) {};
		}
	}
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
//package codeforces;
import java.util.*;
/**
 *
 * @author Ashraf
 */
public class DVA {
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        long n=in.nextLong();
        int k=in.nextInt();
        if(k==0){
            System.out.println(n);
        }
        else if(k==1){
            if(n%10==0){
                System.out.println(n);
            }
            else{
                for(int i=1;i<=10;i++){
                    if((n*i)%10==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
            }
        }
        else if(k==2){
            if(n%100==0){
                System.out.println(n);
            }
            else {
                for(int i=2;i<=100;i++){
                    if((n*i)%100==0&&(n*i)%k==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
            }
        }
        else if(k==3){
            if(n%1000==0){
                System.out.println(n);
            }
            else {
                 for(int i=3;i<=1000;i++){
                    if((n*i)%1000==0&&(n*i)%k==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
            }
        }
        else if(k==4){
            if(n%10000==0){
                System.out.println(n);
            }
            else {
                 for(int i=4;i<=10000;i+=4){
                    if((n*i)%10000==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
            }
        }
        else if(k==5){
            if(n%100000==0){
                System.out.println(n);
            }
            else{
                for(int i=5;i<=100000;i+=5){
                    if((n*i)%100000==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
            }
        }
        else if(k==6){
            if(n%1000000==0){
                System.out.println(n);
            }
            else{
                for(int i=6;i<=100000;i+=6){
                    if((n*i)%100000==0&&(n*i)%k==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
            }
        }
        else if(k==7){
            if(n%10000000==0){
                System.out.println(n);
            }
            else{
                for(int i=7;i<=10000000;i+=7){
                    if((n*i)%10000000==0&&(n*i)%k==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
            }
        }
        else if(k==8){
            if(n%100000000==0){
                System.out.println(n);
            }
            else {
                for(int i=8;i<=12500000;i++){
                    if((n*i)%100000000==0&&(n*i)%k==0){
                        System.out.println(n*i);
                        System.exit(0);
                    }
                }
                System.out.println(n*100000000);
            }
        }
    }
}

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

public class A {
	public static void main(String[] args) throws IOException {
		FastScanner in= new FastScanner(System.in);
		PrintWriter out= new PrintWriter(System.out);

		int n= in.nextInt();
		int k= in.nextInt();
		if(k==0) {
			System.out.println(n);
			return;
		}
		long res= (long) n;
		int mod= 1;
		for (int i = 0; i < k; i++) {
			mod*=10;
		}
		ArrayList<Long> op= new ArrayList<>();
		for(long mult= 1;mult<10;mult++) {
			res= (long) n*mult;
			op.add(res);
		}
		long aa= Long.MAX_VALUE;
		for(long r: op) {
			while(true) {
				if(r%mod!=0) {
					r*=10;
				}
				else {
					aa= Math.min(aa, r);
					break;
				}
			}
		}
		System.out.println(aa);

	}
	static class p implements Comparable<p>{
		int x;
		int y;
		public p(int a, int b) {
			x=a;
			y=b;
		}
		public int compareTo(p o) {
			return this.x-o.x;
		}
	}
	static class FenwickTree {
		long[] ft;
		public FenwickTree(int n) {
			ft = new long[n + 1];
		}

		int rsq(int b) {
			int sum = 0;
			for (; b > 0; b -= (b & (-b)))
				sum += ft[b];
			return sum;
		}

		int rsq(int a, int b) {
			return rsq(b) - (a == 1 ? 0 : rsq(a - 1));
		}

		void update(int k, int v) {
			for (; k < ft.length; k += (k & (-k)))
				ft[k] += v;
		}
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
			st = new StringTokenizer("");
		}

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

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
		public double nextDouble() throws NumberFormatException, IOException {
			return Double.parseDouble(next());
		}
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextInt();
            long k = in.nextInt();

            int n5 = 0;
            long tt = n;
            while (tt % 5 == 0) {
                n5++;
                tt /= 5;
            }

            tt = n;
            int n2 = 0;
            while (tt % 2 == 0) {
                n2++;
                tt /= 2;
            }

            for (int i = 0; i < Math.max(0, n5 - n2); i++) {
                n *= 2;
            }

            for (int i = 0; i < Math.max(0, n2 - n5); i++) {
                n *= 5;
            }

            int t = Math.max(n2, n5);
            while (t < k) {
                n *= 10;
                t++;
            }

            out.println(n);
        }

    }

    static class InputReader {
        StringTokenizer st;
        BufferedReader br;

        public InputReader(InputStream is) {
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            this.br = br;
        }

        public String next() {
            if (st == null || !st.hasMoreTokens()) {
                String nextLine = null;
                try {
                    nextLine = br.readLine();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                if (nextLine == null)
                    return null;
                st = new StringTokenizer(nextLine);
            }
            return st.nextToken();
        }

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

    }
}

import java.util.Scanner;

public class Main {

    public static String make(long k){
        String s="";
        for (int i=0;i<k;i++){
            s+='0';
        }
        return s;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        long k = sc.nextInt();
        long two = 0;
        long five = 0;
        long a = n;
        while (a % 5 == 0) {
            five++;
            a /= 5;
        }
        while (a % 2 == 0) {
            two++;
            a /= 2;
        }
        long ans = 1;
        String s=make(k);
        if (five > two) {
            ans *= (int) Math.pow(2, five - two)*n;
        } else {
            if (two > five) {
                ans *= (int) Math.pow(5, two - five)*n;
            } else {
                if (two == 0) {
                    ans *= (int) Math.pow(10, k - Math.abs(five - two)) * n;
                } else {
                    ans*=n;
                    while(!String.valueOf(ans).contains(s)){
                        ans*=10;
                    }
                }
            }
        }
        while(!String.valueOf(ans).contains(s)){
            ans*=10;
        }
        System.out.println(ans);
    }
}

//package TIM;

import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.*;

public class Main {
    static Scanner input = new Scanner(System.in);
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException {
        long n = input.nextLong();
        long k = input.nextLong();
        if (k == 0) {
            System.out.println(n);
            return;
        }
        if (k == 1) {
            System.out.println(n * 10);
            return;
        }
        long a = 1;
        for (int i = 0; i < k; i++) {
            a *= 10;
        }
        long num = 1, t = 0;
        while (true) {
            t = a * (num++);
            if (t % n == 0) {
                System.out.println(t);
                return;
            }
        }
    }

}

/* package whatever; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class bbg
{
	public static int result;

public static ArrayList<Integer> [] graph;

public static int[]cats;

public static int vizitat[];
public static int x;

	public static void main (String[] args) throws java.lang.Exception
{

Scanner input=new Scanner(System.in);

HashMap<Integer, Integer> contor1= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> contor2= new HashMap<Integer, Integer>();

HashMap<Integer, Integer> map= new HashMap<Integer, Integer>();
HashMap<Integer, Integer> stop= new HashMap<Integer, Integer>();

		Long n=input.nextLong();
		Long k=input.nextLong();

		if(k==0) System.out.println(n);

		else if (cifrezero(n)>=k) System.out.println(n);

		else{

		int number=0;
			Long rasp=n;
		int x=0;

		for(int i=1;i<=10;i++)
		{

		    Long prod=n*i*1L;

		  //  System.out.println(i+" "+prod+" ");

		    if(cifrezero(prod)>number) {rasp=prod; number=cifrezero(prod);}

		  else   if(cifrezero(prod)==number && prod<rasp ) {rasp=prod;
		    number=cifrezero(prod);}

		}

		System.out.print(rasp);

	for(int j=1;j<=k-cifrezero(rasp);j++) System.out.print("0");

		}

		}

		public static int cifrezero(Long nr){

			Long part=nr;
			int contor=0;
			while(part>0l && part%10==0){
				contor++;
				part=part/10l;

			}

			return contor;

		}

		}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main
{

	static Scanner in = new Scanner(System.in);

	// static final double EPS = 1e-7;
	// static final double HALFPI = Math.PI / 2.0;

	public static void main(String[] args) throws IOException
	{
		// BufferedReader br = new BufferedReader(new
		// InputStreamReader(System.in));
		// StringTokenizer st = new StringTokenizer(br.readLine());

		int cnt2 = 0;
		int cnt5 = 0;
		int n = in.nextInt();
		int k = in.nextInt();
		int ori = n;
		while (true)
		{
			if (n % 2 == 0)
			{
				cnt2++;
				n /= 2;
			} else
				break;
		}
		while (true)
		{
			if (n % 5 == 0)
			{
				cnt5++;
				n /= 5;
			} else
				break;
		}
		StringBuilder sb = new StringBuilder();
		if (cnt2 + cnt5 == 0)
		{
			sb.append(n);
			for (int i = 0; i < k; i++)
				sb.append(0);
		} else
		{
			long ans = ori;
			if (cnt2 >= cnt5)
			{
				for (int i = 0; i < cnt2 - cnt5; i++)
					ans = ans * 5;
			} else
			{
				for (int i = 0; i < cnt5 - cnt2; i++)
					ans = ans * 2;
			}
			sb.append(ans);
			int cnt0 = 0;
			long temp = ans;
			while (true)
			{
				if (temp % 10 == 0)
				{
					cnt0++;
					temp /= 10;
				}else
					break;
			}
			if(cnt0<k){
				for(int i=0;i<k-cnt0;i++){
					sb.append(0);
				}
			}
		}
		System.out.println(sb);
	}
}

import java.util.*;

public class X
{

public static void main (String[] args)
	{

	 Scanner  s=new Scanner(System.in);
     long n=s.nextLong();
     int k=s.nextInt();
     int pow=(int)Math.pow(10,k);
     for(int i=1;i<=pow;i++){
    	 long temp=n*i;
    	 if(temp%k==0){
    		 System.out.println(temp);break;}
     }

	 s.close();
	}

}

import java.util.Scanner;

public class N1_tech_17092017 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        long a=scanner.nextInt();
        int b=scanner.nextInt();
        boolean flag=false;
        long res;
        if ((a%10)%2==0)flag=true;

        long k=func(a);
        //465

        if (k>=b)res=a;else
        {
            if (flag){
                a=a*5;
                while (func(a)>=b){
                    a*=10;
                }
                res=a;
            }else{
                long fifth=function5(a);
                while(fifth>0 && func(a)<b){
                    a*=2;
                    fifth--;
                    //res=a;
                }
                //res=a;
                while (func(a)<b)
                {
                    a*=10;
                }
                res=a;
            }
        }
        System.out.println(res);
    }
    public static long func(long a)
    {
        long k=0;
        while (a!=0) {
            if ((a%10)==0)k++ ;else break;
            a=a/10;
        }
        return k;
    }
    public static long function5 (long a){
        long k=0;
        while (a%5==0){
            k++;
            a/=5;
        }
        return k;
    }
}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
//package codeforces;
import java.util.*;
/**
 *
 * @author Ashraf
 */
public class kthRounding {
    public static void main(String []args){
        Scanner in=new Scanner(System.in);
        long n=in.nextLong();
        int k=in.nextInt();
        String s="",c="";
        if(k==0){
            System.out.println(n);
        }
        else if(k==1){
            if(n%10==0){
                System.out.println(n);
            }
            else {
                System.out.println(n*10);
            }
        }
        else if(k==2){
            if(n%100==0){
                System.out.println(n);
            }
            else {
                s=String.valueOf(n);
                for(int i=0;i<s.length();i++){
                    char p=s.charAt(i);
                    c+=p;
                    int x=Integer.parseInt(c);
                    if((x*100)%n==0){
                        System.out.println(x*100);
                        System.exit(0);
                    }
                }
                System.out.println(n*100);
            }
        }
        else if(k==3){
            if(n%1000==0){
                System.out.println(n);
            }
            else {
                s=String.valueOf(n);
                for(int i=0;i<s.length();i++){
                    char p=s.charAt(i);
                    c+=p;
                    int x=Integer.parseInt(c);
                    if((x*1000)%n==0){
                        System.out.println(x*1000);
                        System.exit(0);
                    }
                }
                System.out.println(n*1000);
            }
        }
        else if(k==4){
            if(n%10000==0){
                System.out.println(n);
            }
            else {
                s=String.valueOf(n);
                for(int i=0;i<s.length();i++){
                    char p=s.charAt(i);
                    c+=p;
                    int x=Integer.parseInt(c);
                    if((x*1000)%n==0){
                        System.out.println(x*10000);
                        System.exit(0);
                    }
                }
                System.out.println(n*10000);
            }
        }
        else if(k==5){
            if(n%100000==0){
                System.out.println(n);
            }
            else {
                s=String.valueOf(n);
                for(int i=0;i<s.length();i++){
                    char p=s.charAt(i);
                    c+=p;
                    int x=Integer.parseInt(c);
                    if((x*1000)%n==0){
                        System.out.println(x*100000);
                        System.exit(0);
                    }
                }
                System.out.println(n*100000);
            }
        }
        else if(k==6){
            if(n%1000000==0){
                System.out.println(n);
            }
            else {
                s=String.valueOf(n);
                for(int i=0;i<s.length();i++){
                    char p=s.charAt(i);
                    c+=p;
                    int x=Integer.parseInt(c);
                    if((x*1000000)%n==0){
                        System.out.println(x*1000000);
                        System.exit(0);
                    }
                }
                System.out.println(n*1000000);
            }
        }
        else if(k==7){
            if(n%10000000==0){
                System.out.println(n);
            }
            else {
                s=String.valueOf(n);
                for(int i=0;i<s.length();i++){
                    char p=s.charAt(i);
                    c+=p;
                    int x=Integer.parseInt(c);
                    if((x*10000000)%n==0){
                        System.out.println(x*10000000);
                        System.exit(0);
                    }
                }
                System.out.println(n*10000000);
            }
        }
        else if(k==8){
            if(n%100000000==0){
                System.out.println(n);
            }
            else {
                s=String.valueOf(n);
                for(int i=0;i<s.length();i++){
                    char p=s.charAt(i);
                    c+=p;
                    int x=Integer.parseInt(c);
                    if((x*100000000)%n==0){
                        System.out.println(x*100000000);
                        System.exit(0);
                    }
                }
                System.out.println(n*100000000);
            }
        }
    }

}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Arrays;

public class Solution
{

    public static void main(String[] args) {
        Reader in = new Reader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt() ,
                k = in.nextInt() ,
                z = getZeroes(n) , max2 , max5;
        long res;
        boolean toCont = true;

        max2 = getMaxPow(n , 2);
        max5 = getMaxPow(n , 5);

        res = (long) (Math.pow(2 , k - max2) * Math.pow(5 , k - max5) * n);

        out.println(res);
        out.close();
    }

    public static int getMaxPow(int val , int div)
    {
        int pow = 0;
        while(val % Math.pow(div , pow) == 0) { pow++; }
        return pow - 1;
    }

    public static int getZeroes(int val)
    {
        int z = 0 , pow = 10;
        while(val % pow == 0)
        {
            pow *= 10;
            z++;
        }
        return z;
    }

    static class Reader
    {

        private BufferedReader reader;
        private StringTokenizer tokenizer;

        public Reader(InputStream in)
        {
            reader = new BufferedReader(new InputStreamReader(in));
            tokenizer = null;
        }

        public String next()
        {
            while(tokenizer == null || !tokenizer.hasMoreTokens())
            {
                try
                {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }
            return tokenizer.nextToken();
        }

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

    }

}

import java.util.Scanner;

public class TaskA {

    public static void main(String[] args) {
        Solver();
    }

    static void Solver() {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int k= in.nextInt();
        long ans;
        long ar[] = new long [9];
        int len = 0;
        for (int i = 1; i <= 9; i++)
        {
            long t = n * i;
            ar[len++] = Add(t, k);
        }
        ans = SeekMin(ar, 9);
        System.out.println(ans);
    }

    static long Add(long a, long k)
    {
        long r = 0;
        long rem = a;
        while (a % 10 == 0)
        {
            r++;
            a /= 10;
        }
        a = rem;
        for (long i = r; i < k; i++)
            a *= 10;
        return a;
    }

    static long SeekMin(long a[], long l)
    {
        long min = a[0];
        for (int i = 1; i < l; i++)
            if (a[i] < min)
                min = a[i];
        return min;
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
import java.math.BigInteger;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Ocykat
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Prob861A solver = new Prob861A();
        solver.solve(1, in, out);
        out.close();
    }

    static class Prob861A {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            long rn = in.nextLong();
            int k = in.nextInt();
            if (k == 0) {
                out.println(rn);
                return;
            }
            BigInteger n = new BigInteger(Long.toString(rn));
            BigInteger nn = n;
            int pnZeros = numberOfZero(n);
            int nnZeros = pnZeros;
            int cnt = 2;
            while ((nnZeros < k)) {
                nn = n.multiply(BigInteger.valueOf(cnt));
                nnZeros = numberOfZero(nn);
                if (pnZeros != nnZeros) {
                    cnt = 2;
                    n = nn;
                }
                pnZeros = nnZeros;
                cnt += 2;
            }
            out.println(nn);
            return;
        }

        private int numberOfZero(BigInteger n) {
            int res = 0;
            while (n.mod(BigInteger.TEN).equals(BigInteger.ZERO)) {
                n = n.divide(BigInteger.TEN);
                res++;
            }
            return res;
        }

    }
}

import java.util.Scanner;
import java.awt.image.BandedSampleModel;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class A{

    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);

        {
            long n=sc.nextLong();
            long k=sc.nextLong();
            long copy = n;

            int two=0;
            int five=0;
            while(copy%2==0)
            {
                two++;
                copy=copy/2;
            }
            while(copy%5==0)
            {
                five++;
                copy=copy/5;
            }

            if(k==0)
            {
                System.out.println(n);
            }
            else if(Math.min(two,five)>=k)
            {
                System.out.println(n);
            }
            else
            {
                long ans=copy;
                for(int j=0;j<k;j++)
                {
                    ans=ans*10;
                }

                while(ans%n!=0)
                {
                    ans=ans*10;
                }
                System.out.println(ans);

            }
        }

    }
}