#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <functional>
#include <complex>
#include <queue>
#include <stack>
#include <cmath>
#include <cassert>
#include <tuple>
using namespace std;
typedef long long LL;
typedef complex<double> CMP;
class ReProduct { public:
long long minimize(vector <int> base, int goal)
{
vector<tuple<LL,int,int,int,int>> cand(1, make_tuple(0LL,-1,-1,-1,-1));
for (LL a = 1,ai=0; a <= 1000000000000000000LL; a *= 2,++ai)
for (LL b = a,bi=0; b <= 1000000000000000000LL; b *= 3,++bi)
for (LL c = b,ci=0; c <= 1000000000000000000LL; c *= 5,++ci)
for (LL d = c,di=0; d <= 1000000000000000000LL; d *= 7,++di)
cand.emplace_back(d, ai,bi,ci,di);
vector<LL> vs;
for (auto cc : cand) {
LL c = get<0>(cc);
LL v = value(c, base);
if (v == goal)
vs.push_back(c);
if (v + 1 == goal)
if (c == 0)
vs.push_back(10);
else if (c==1)
vs.push_back(11);
else {
int p2 = get<1>(cc);
int p3 = get<2>(cc);
int p5 = get<3>(cc);
int p7 = get<4>(cc);
if (p2 + p3 + p5 + p7 >= 2) {
vector<int> ds;
for (int _ = 0; _ < p5; ++_) ds.push_back(5);
for (int _ = 0; _ < p7; ++_) ds.push_back(7);
if (ds.empty() && p2 + p3 == 2) {
for (int _ = 0; _ < p2; ++_) ds.push_back(2);
for (int _ = 0; _ < p3; ++_) ds.push_back(3);
}
else if (ds.empty() && p2 == 3 && p3 == 0) {
ds.push_back(2);
ds.push_back(4);
}
else {
for (; p2 >= 3; p2 -= 3) ds.push_back(8);
for (; p3 >= 2; p3 -= 2) ds.push_back(9);
if (p2 == 0) {
if (p3 == 0) {}
else if (p3 == 1) { ds.push_back(3); }
}
else if (p2 == 1) {
if (p3 == 0) { ds.push_back(2); }
else if (p3 == 1) { ds.push_back(6); }
}
else if (p2 == 2) {
if (p3 == 0) { ds.push_back(4); }
else if (p3 == 1) { ds.push_back(2); ds.push_back(6); }
}
}
sort(ds.begin(), ds.end());
if (ds.size() <= 18) {
LL u = 0;
for (int d : ds)
u = u * 10 + d;
vs.push_back(u);
}
}
}
}
return *min_element(vs.begin(), vs.end());
}
int value(LL x, const vector<int>& base) {
if (x <= 9)
return base[int(x)];
LL p = 1;
for (; x; x /= 10)
p = p * (x % 10);
return value(p, base) + 1;
}
};
// BEGIN CUT HERE
#include <ctime>
double start_time; string timer()
{ ostringstream os; os << " (" << int((clock()-start_time)/CLOCKS_PER_SEC*1000) << " msec)"; return os.str(); }
template<typename T> ostream& operator<<(ostream& os, const vector<T>& v)
{ os << "{ ";
for(typename vector<T>::const_iterator it=v.begin(); it!=v.end(); ++it)
os << '\"' << *it << '\"' << (it+1==v.end() ? "" : ", "); os << " }"; return os; }
void verify_case(const long long& Expected, const long long& Received) {
bool ok = (Expected == Received);
if(ok) cerr << "PASSED" << timer() << endl; else { cerr << "FAILED" << timer() << endl;
cerr << "\to: \"" << Expected << '\"' << endl << "\tx: \"" << Received << '\"' << endl; } }
#define CASE(N) {cerr << "Test Case #" << N << "..." << flush; start_time=clock();
#define END verify_case(_, ReProduct().minimize(base, goal));}
int main(){
CASE(0)
int base_[] = {0,1,1,1,1,1,1,1,1,1};
vector <int> base(base_, base_+sizeof(base_)/sizeof(*base_));
int goal = 2;
long long _ = 11LL;
END
CASE(1)
int base_[] = {0,0,0,0,0,0,0,0,0,0};
vector <int> base(base_, base_+sizeof(base_)/sizeof(*base_));
int goal = 3;
long long _ = 39LL;
END
CASE(2)
int base_[] = {2,0,0,0,0,0,0,0,0,0};
vector <int> base(base_, base_+sizeof(base_)/sizeof(*base_));
int goal = 2;
long long _ = 0LL;
END
CASE(3)
int base_[] = {2,2,2,2,2,2,2,2,0,2};
vector <int> base(base_, base_+sizeof(base_)/sizeof(*base_));
int goal = 1;
long long _ = 18LL;
END
CASE(4)
int base_[] = {2,1,2,2,1,1,1,0,1,0};
vector <int> base(base_, base_+sizeof(base_)/sizeof(*base_));
int goal = 6;
long long _ = 268LL;
END
CASE(5)
int base_[] = { 2,1,2,2,1,1,1,0,1,0 };
vector <int> base(base_, base_+sizeof(base_)/sizeof(*base_));
int goal = 11;
long long _ = -1LL;
END
/*
CASE(6)
int base_[] = ;
vector <int> base(base_, base_+sizeof(base_)/sizeof(*base_));
int goal = ;
long long _ = LL;
END
*/
}
// END CUT HERE