protected class A : public C{
public:
    int X() {
        return x;
    }
private:
    int x;
}

const int MAXN = 10000;
int num[MAXN + 1];
int main(void)
{
    memset(num,0,sizeof(num));
    for(int i = 1; i <= MAXN; ++i)
    {
        for(int j = i * 2; j <= MAXN; j += i)
            num[j] += i;
    }
    int ans = 0;
    for(int i = 1; i <= MAXN; ++i)
    {
        if(num[i] <= MAXN && num[ num[i] ] == i && num[i] != i) // "num[i] != i" is important
            ans += i;
    }
    cout << ans << endl;
    return 0;
}

string next(ifstream& in)
{
    vector<char> buffer;
    char tmp = -1;
    while(in >> tmp && tmp != '"');
    if(tmp == -1)
        return string(1,'\0');
    in >> tmp;
    do{
        buffer.emplace_back(tmp); // There would not read '"' into buffer.
        in >> tmp;
    }while(tmp != '"');
    string str(buffer.size(), '\0');
    auto viter = buffer.begin();
    auto siter = str.begin();
    while(viter != buffer.end() && siter != str.end())
        *siter++ = *viter++;
    return str;
}
int main()
{

    ifstream dataStreamer;
    dataStreamer.open("p022_names.txt", ios::in, _SH_DENYWR);
    if(!dataStreamer)
    {
            cout<<"文件读错误";
            system("pause");
            exit(1);
    }

    set<string> s;
    while(true)
    {
        string str = next(dataStreamer);
        if(str.size() == 1)
            break;
        s.insert(str);
    }
    dataStreamer.close();
    int ans = 0;
    {
        int cnt = 1;
        for(string e : s)
        {
            int tmp = 0;
            for(char c : e)
               tmp += c - 'A' + 1;
            ans += cnt * tmp;
            ++cnt;
        }
    }
    cout << ans << endl;
    return 0;
}

int abundantNumberCheck[28123 + 1];
bool abundantNumberMixed[28123 + 1];
int main()
{
    memset(abundantNumberCheck, 0, sizeof(abundantNumberCheck));
    memset(abundantNumberMixed, 0, sizeof(abundantNumberMixed));
    vector<int> abunantNumber;
    for(int i = 2;i <= 28123; ++i)
    {
        for(int j = i * 2; j <= 28123; j += i)
            abundantNumberCheck[j] += i;
        if(abundantNumberCheck[i] > i)
            abunantNumber.push_back(i);
    }

    for(size_t v1 = 0; v1 < abunantNumber.size(); ++v1)
        for(size_t v2 = v1; v2 < abunantNumber.size(); ++v2)  // it means that a number can be expressed two same numbers
        {
            if(abunantNumber[v1] + abunantNumber[v2] > 28123)
                break;
            abundantNumberMixed[ abunantNumber[v1] + abunantNumber[v2] ] = true;
        }
    int sum = 0;
    for(int i = 1; i < 28123 + 1; ++i)
    {
        if(abundantNumberMixed[i] == false)
            sum += i;
    }
    cout << sum << endl;
    return 0;
}

const int TARGET = 1e6;
const int RANGE = 10;
int getPro(int n)
{
    int ans = 1;
    for(int i = n; i > 1; --i)
        ans *= i;
    return ans;
}
list<int> num;
void dfs(int target, int p, queue<int> &s)
{
    if(p == 1)
    {
        s.push(*num.begin());
        return ;
    }
    int part = getPro(p-1);
    cout << "part" << part << endl;
    auto i = num.begin();
    for(;i != num.end(); ++i)
        if(target <= part)
        {
            cout << *i << "b" << endl;
            break;
        }
        else
            target -= part;
    s.push(*i);
    num.erase(i);
    dfs(target, p-1,s);
}

int main(void)
{
    queue<int> s;
    for(int i = 0; i < RANGE; ++i)
        num.push_back(i);
    dfs(TARGET, RANGE, s);
    long long ans = 0;
    while(!s.empty())
    {
        cout << s.front() << "xxx" << endl;
        ans = ans * 10 + s.front();
        s.pop();
    }
    cout << setfill('0') << setw(10) << ans << endl;
    return 0;
}

int main()
{
    BigInt f[] = {BigInt::One(), BigInt::One(), BigInt::One()};
    int cnt = 0;
    while(f[cnt % 3].size() < 1000)
    {
        f[cnt % 3] = f[(cnt+1) % 3] + f[(cnt+2) % 3];
        ++cnt;
    }
    cout << cnt << endl;
    return 0;
}

class BigInt
{
public:
    BigInt(int num);
    BigInt(const BigInt&);
    BigInt(BigInt&& o) noexcept;
    BigInt& operator = (const BigInt&);
    static BigInt Zero();
    static BigInt One();

    bool operator == (const BigInt&) const;
    BigInt& operator ++(); //++i
    BigInt& operator --(); //--i
    BigInt operator +(const BigInt&);
    BigInt operator +=(const BigInt&);
    BigInt operator *(const BigInt&);
    BigInt operator *=(const BigInt&);

    inline size_t& size();
    inline size_t size() const;
    string toString() const;
    ~BigInt();

    friend ostream& operator << (ostream& out, const BigInt& o)
    {
        auto ptr = o.m_num + o.size();
        do{
            --ptr;
            out << *ptr;
        }while(ptr != o.m_num);
        return out;
    }
private:
    BigInt();
    int* m_num;
    size_t m_size;
    void format();
};
size_t& BigInt::size()
{
    return m_size;
}
size_t BigInt::size() const
{
    return m_size;
}
BigInt::BigInt()
{
}
BigInt::~BigInt()
{
    if(m_num != nullptr)
    delete[] m_num;
    m_size = 0;
}
BigInt::BigInt(int num)
{
    size_t cnt = 0;
    {
        int tmp = num;
        do{
            ++cnt;
            tmp /= 10;
        }while(tmp != 0);
    }
    size() = cnt;
    m_num = new int[size()];
    auto ptr = m_num;
    do{
        *ptr = num % 10;
        num /= 10;
        ++ptr;
    }while(num != 0);
}
BigInt::BigInt(const BigInt& o)
{
    size() = o.size();
    m_num = new int[size()];
    memcpy(m_num, o.m_num, size() * sizeof(int));
}
BigInt::BigInt(BigInt&& o) noexcept
{
    size() = o.size();
    m_num = o.m_num;
    //delete;
    o.size() = 0;
    o.m_num = nullptr;
}
BigInt& BigInt::operator = (const BigInt& o)
{
    size() = o.size();
    if(m_num != nullptr)
        delete [] m_num;
    m_num = new int[size()];
    memcpy(m_num, o.m_num, size() * sizeof(int));
    return *this;
}
BigInt BigInt::Zero()
{
    BigInt a(0);
    return a;
}
BigInt BigInt::One()
{
    BigInt a(1);
    return a;
}
bool BigInt::operator==(const BigInt& o) const
{
    if(size() != o.size())
        return false;
    for(size_t i = 0; i < size(); ++i)
        if(m_num[i] != o.m_num[i])
            return false;
    return true;
}
BigInt& BigInt::operator ++()
{
    ++m_num[0];
    format();
    return *this;
}
BigInt& BigInt::operator --()
{
    --m_num[0];
    format();
    return *this;
}
void BigInt::format()
{
    // Carry
    for(size_t i = 0; i < size() - 1; ++i)
        if(m_num[i] >= 10)
        {
            m_num[i+1] += m_num[i] / 10;
            m_num[i] %= 10;
        }
        else
            if(m_num[i] < 0)
            {
                int cnt = (m_num[i] / 10 + 1);
                m_num[i] += cnt * 10;
                m_num[i+1] -= cnt;
            }
    // Stretch out digital
    if(m_num[size() - 1] >= 10)
    {
        int* new_num = new int[size() + 1];
        memcpy(new_num, m_num, size() * sizeof(int));
        new_num[size()] = new_num[size() - 1] / 10;
        new_num[size() - 1] %= 10;
        ++size();
        if(m_num != nullptr)
            delete [] m_num;
        m_num = new_num;
    }
    // Draw back digital
    if(size() == 1)
        return;
    auto ptr = m_num + size();
    do{
        --ptr;
        if(*ptr != 0)
            break;
    }while(ptr != m_num);
    size_t new_size = static_cast<size_t>(ptr - m_num + 1);
    if(size() != new_size)
    {
        int* new_num = new int[new_size];
        memcpy(new_num, m_num, new_size * sizeof(int));
        if(m_num != nullptr)
            delete [] m_num;
        m_num = new_num;
        size() = new_size;
    }
}
BigInt BigInt::operator +(const BigInt& o)
{
    BigInt ans;
    size_t length = max(size(), o.size());
    ans.m_num = new int[length];
    ans.size() = length;
    for(size_t i = 0; i < min(size(), o.size()); ++i)
        ans.m_num[i] = m_num[i] + o.m_num[i];
    if(size() > o.size())
        for(size_t i = o.size(); i < size(); ++i)
            ans.m_num[i] = m_num[i];
    else
        for(size_t i = size(); i < o.size(); ++i)
            ans.m_num[i] = o.m_num[i];
    ans.format();
    return ans;
}
BigInt BigInt::operator+=(const BigInt& o)
{
    if(size() < o.size())
    {
        int* new_num = new int[o.size()];
        memcpy(new_num,m_num,size());
        for(size_t i = size(); i < o.size(); ++i)
            new_num[i] = 0;
        delete [] m_num;
        m_num = new_num;
    }
    for(size_t i = 0; i < o.size(); ++i)
        m_num[i] += o.m_num[i];
    format();
    return *this;
}
BigInt BigInt::operator *=(const BigInt& o)
{
    size_t new_size = size() + o.size() - 1;
    int* new_num = new int[new_size];
    memset(new_num, 0, new_size * sizeof(int));
    for(size_t i = 0; i < size(); ++i)
        for(size_t j = 0; j < o.size(); ++j)
            new_num[i + j] += m_num[i] * o.m_num[j];
    size() = new_size;
    delete [] m_num;
    m_num = new_num;
    format();
    return *this;
}
BigInt BigInt::operator *(const BigInt& o)
{
    BigInt ans;
    size() = size() + o.size() - 1;
    ans.m_num = new int[size()];
    memset(ans.m_num, 0, size() * sizeof(int));
    for(size_t i = 0; i < size(); ++i)
        for(size_t j = 0; j < o.size(); ++j)
            ans.m_num[i + j] += m_num[i] * o.m_num[j];
    ans.format();
    return ans;
}
string BigInt::toString() const
{
    char* str = new char[size() + 1];
    for(size_t i = 0; i < size(); ++i)
        str[size() - i - 1] = static_cast<char>(m_num[i] + '0');
    str[size()] = '\0';
    string ans = string(str);
    delete str;
    return ans;
}
BigInt mulpow(BigInt base, int index)
{
    BigInt ans = BigInt::One();
    while(index != 0)
    {
        if(index & 1)
            ans *= base;
        index >>= 1;
        base *= base;
    }
    return ans;
}
int main()
{
    BigInt ans = mulpow(BigInt(2), 1000);
    string str = ans.toString();
    int count = 0;
    for(auto iter = str.begin(); iter != str.end(); ++iter)
        count += (*iter) - '0';
    cout <<count << endl;
    return 0;
}

int main()
{
    const int HUNDRED = 7;
    const int THOUSAND = 8;
    const int AND = 3;
    const int single_digit[9] = {3, 3, 5, 4, 4, 3, 5, 5, 4};
    const int double_digit_1[10] = {3, 6, 6, 8, 8, 7, 7, 9, 8, 8};
    const int double_digit_2[8] = {6, 6, 5, 5, 5, 7, 6, 6};
    // calc 1 - 9
    int single_count = 0;
    for(auto e : single_digit)
        single_count += e;
    
    // calc 10~19
    int double_count = 0;
    for(auto e : double_digit_1)
        double_count += e;
    
    // calc 20 ~ 99
    for(auto e : double_digit_2)
        double_count += e * 10 + single_count;

    // calc 100 ~ 999
    int three_count = 0;
    for(auto e : single_digit)
    {
        three_count += (e + HUNDRED) * 1; // 100 200 300 ...
        three_count += (e + HUNDRED + AND) * 9 + single_count; // 101 ... 201 ...
        three_count += (e + HUNDRED + AND) * 90 + double_count; // 110 ... 210 ...
    }

    // calc 1000
    int four_count = single_digit[0] + THOUSAND;

    cout << single_count + double_count + three_count + four_count << endl;
    return 0;
}

const int MAXN = 100;
int maps[MAXN+1][MAXN+1];
int dp[MAXN+1][MAXN+1];
int max(int a,int b)
{
    return (a > b) ? a : b;
}
int main(void)
{
    for(int i = 1; i <= MAXN; ++i)
        for(int j = 1; j <= i; ++j)
            cin >> maps[i][j];
    for(int i = MAXN - 1; i >= 1; --i)
    {
        for(int j = 1; j <= i; ++j)
            dp[i][j] = max(dp[i+1][j] + maps[i+1][j], dp[i+1][j+1] + maps[i+1][j+1]);
    }
    cout << dp[1][1] + maps[1][1] << endl;
    return 0;
}

int isLeap(int year, int month)
{
    if(month != 1)
        return 0;
    if(year % 100 == 0)
        return (year % 400 == 0) ? 1 : 0;
    else
        return (year % 4 == 0) ? 1 : 0;
}
int main(void)
{
    const int dayPerMonth[12]={31,28,31,30,31,30,31,31,30,31,30,31};
    int nowDay = 0;
    int ans = 0;
    for(int year = 1901; year <= 2000; ++year)
        for(int month = 0; month < 12; ++month)
        {
            if(nowDay == 0)
                ++ans;
            nowDay = (nowDay + dayPerMonth[month] + isLeap(year, month)) % 7;
        }
    cout << ans << endl;
    return 0;
}

int main(void)
{
    const int n = 100;
    int a = n * (n+1) / 2;
    a *= a;
    int b = n * (n+1) * (2*n+1) / 6;
    cout << a - b << endl;
    return 0;
}

bool isprime(int n)
{
    if(n == 1)
        return false;
    if(n < 4)
        return true;
    if(n % 2 == 0)
        return false;
    if(n < 9)
        return true;
    if(n % 3 == 0)
        return false;
    int upper = static_cast<int>(sqrt(n));
    for(int i = 5; i <= upper;)
    {
        if(n % i == 0 || n % (i+2) == 0)
            return false;
        i += 6;
    }
    return true;
}

int main(void)
{
    int num = 1;
    int count = 0;
    int limit = 10001;
    while(count < limit)
    {
        ++num;
        if(isprime(num))
            ++count;
    }
    cout << num << endl;
    return 0;
}

char maps[20 * 51];
int main(void)
{
    for(int i = 0; i < 20; ++i)
        scanf("%s",maps + (i * 50));
    for(int i = 0; i < 20 * 50; ++i)
            maps[i] -= '0';
    long long maxs = -1LL;
    long long tmp = 1LL;

    int count = 0;
    for(int i = 0; i < 20 * 50; ++i)
    {
        if(maps[i] == 0)
        {
            count = 0;
            tmp = 1LL;
            continue;
        }
        tmp *= maps[i];
        ++count;
        if(count > 13)
        {
            tmp /= maps[i-13];
            --count;
        }
        if(count == 13)
        {
            maxs = max(maxs, tmp);
        }
    }

    cout << maxs << endl;
    return 0;
}

int main(void)
{
    for(int b = 1; b < 1000; ++b)
        for(int a = 1; a < b; ++a)
            if(1000000 - 2000*(a+b) + 2*a*b == 0)
            {
                cout << 1LL * a * b * (1000-a-b) << endl;
                break;
            }
    return 0;
}

int gcd(int a, int b)
{
    return (b != 0) ? gcd(b,a%b) : a;
}
int main(void)
{
    int s2 = 1000 / 2;
    int mlimit = static_cast<int>( ceil(sqrt(s2)) ) - 1;
    for(int m = 2; m <= mlimit; ++m)
        if(s2 % m == 0)
        {
            int sm = s2 / m;
            while(sm % 2 == 0)
                sm = sm / 2;
            int k;
            if(m % 2 == 1)
                k = m + 2;
            else
                k = m + 1;
            while( k < 2 * m && k <= sm )
            {
                if(sm % k == 0 && gcd(k, m) == 1)
                {
                    int d = s2 / (k*m);
                    int n = k - m;
                    int a = d * (m * m - n * n);
                    int b = 2 * d * m * n;
                    int c = d * (m * m + n * n);
                    printf("%d %d %d %d",a,b,c,a*b*c);
                    return 0;
                }
                k += 2;
            }
        }
    return 0;
}

void sieve(vector<int>& v, const int upper)
{
    bool *num = new bool[static_cast<unsigned long long>(upper)];
    memset(num, false, sizeof(bool) * upper);
    for(int i = 2; i <= upper; ++i)
    {
        if(num[i] == false)
        {
            v.push_back(i);
            int p = 2;
            while(i * p < upper)
            {
                num[i*p] = true;
                ++p;
            }
        }
    }
    delete[] num;
}
int main(void)
{
    vector<int> v;
    const int upper = 2e6;
    sieve(v,upper+1);
    long long sum = 0;
    for(auto i : v)
        sum += i;
    cout << sum << endl;
    return 0;
}

int main(void)
{
    for(int i = 0; i < 20; ++i)
        for(int j = 0; j < 20; ++j)
            cin >> maps[i][j];

    int ans = 0;
    int tmp;

    // horizontal
    for(int i = 0; i < 20; ++i)
        for(int j = 0; j < 20 - 4; ++j)
        {
            tmp = 1;
            for(int k = 0; k < 4; ++k)
                tmp *= maps[i][j+k];
            ans = max(ans,tmp);
        }
    // vertical
    for(int i = 0; i < 20 - 4; ++i)
        for(int j = 0; j < 20; ++j)
        {
            tmp = 1;
            for(int k = 0; k < 4; ++k)
                tmp *= maps[i+k][j];
            ans = max(ans,tmp);
        }

    // diagonal1
    for(int i = 0; i < 20 - 4; ++i)
        for(int j = 0; j < 20 - 4; ++j)
        {
            tmp = 1;
            for(int k = 0; k < 4; ++k)
                tmp *= maps[i+k][j+k];
            ans = max(ans,tmp);
        }
    // diagonal2

    for(int i = 3; i < 20; ++i)
        for(int j = 0; j < 20 - 4; ++j)
        {
            tmp = 1;
            for(int k = 0; k < 4; ++k)
                tmp *= maps[i-k][j+k];
            ans = max(ans,tmp);
        }

    cout << ans << endl;
    return 0;
}

bool isaccepted(long long num)
{
    int factor_count = 0;
    long long upper = static_cast<long long>(sqrt(num));
    for(int i = 2; i < upper; ++i)
        if(num % i == 0)
            factor_count += 2;
    if(upper * upper == num)
        factor_count += 1;
    if(factor_count >= 500)
        return true;
    else
        return false;
}
int main(void)
{
    int ans = 1;
    int i = 1;
    while(!isaccepted(ans))
        ans += ++i;
    cout << ans << endl;
    return 0;
}

class BigInt
{
public:
    const size_t SIZE = 60;

    BigInt();
    ~BigInt();
    BigInt(int num);
    BigInt(BigInt&& b);
    BigInt(const BigInt& b);
    BigInt& operator = (const BigInt&);
    bool operator == (const BigInt& b);
    void operator += (const BigInt& b);
    string toString();
    friend istream& operator >> (istream& in, BigInt& b)
    {
        string str;
        in >> str;
        auto p = str.rbegin();
        size_t postion = 0;
        while(p != str.rend())
        {
            b.m_num[postion] = (*p) - '0';
            ++postion;
            ++p;
        }
        return in;
    }
    friend ostream& operator <<(ostream& out, const BigInt& b)
    {
        size_t postion = b.SIZE - 1;
        while(b.m_num[postion] == 0 && postion != 0)
            --postion;
        while(postion != 0)
        {
            out << static_cast<int>(b.m_num[postion]);
            --postion;
        }
        out << static_cast<int>(b.m_num[0]);
        return out;
    }
private:
    char* m_num;
};

BigInt::BigInt()
{
    m_num = new char[SIZE];
    memset(m_num, 0, sizeof(char) * SIZE);
}

BigInt::~BigInt()
{
    if(m_num != nullptr)
        delete[] m_num;
}
BigInt::BigInt(int num)
{
    assert(num >= 0);
    m_num = new char[SIZE];
    memset(m_num, 0, sizeof(char) * SIZE);
    int p = 0;
    do{
        m_num[p] = num % 10;
        num /= 10;
        p++;
    }while(num != 0);
}
BigInt::BigInt(BigInt&& b)
{
    m_num = b.m_num;
    b.m_num = nullptr;
}
BigInt::BigInt(const BigInt& b)
{
    this->m_num = b.m_num;
}
bool
BigInt::operator==(const BigInt& b)
{
    for(size_t i = 0;i < SIZE; ++i)
        if(m_num[i] != b.m_num[i])
            return false;
    return true;
}
void
BigInt::operator+=(const BigInt& b)
{
    for(size_t i = 0; i < SIZE; ++i)
        m_num[i] += b.m_num[i];
    for(size_t i = 0; i < SIZE - 1; ++i)
    {
        m_num[i + 1] += m_num[i] / 10;
        m_num[i] = m_num[i] % 10;
    }
}
string
BigInt::toString()
{
    size_t postion = SIZE - 1;
    while(m_num[postion] == 0 && postion != 0)
        --postion;
    string str(postion + 1, '\0');
    auto p = str.begin();
    while(postion != 0)
    {
        (*p) = m_num[postion] + '0';
        --postion;
        ++p;
    }
    (*p) = m_num[postion] + '0';
    return str;
}
int main(void)
{
    BigInt sum,tmp;
    while(cin >> tmp)
        sum += tmp;
    cout << sum.toString().substr(0,10) << endl;
    return 0;
}

const int MAXN = 1e6;
int num[MAXN+2];
int main(void)
{
    memset(num,0,sizeof(num));
    num[1] = 1;
    int ans = 1;
    stack<long long> s;
    for(int i = 1; i <= MAXN; ++i)
    {
        if(num[i] == 0)
        {
            s.push(i);
            long long tmp = i;
            int count;
            while(tmp != 1)
            {
                tmp = (tmp % 2) ? (3 * tmp + 1) : (tmp / 2);
                if(tmp <= MAXN && num[tmp] != 0)
                {
                    count = num[tmp];
                    while(!s.empty())
                    {
                        ++count;
                        if(s.top() <= MAXN)
                            num[s.top()] = count;
                        s.pop();
                    }
                    break;
                }
                s.push(tmp);
            }
        }
        if(num[ans] < num[i])
            ans = i;
    }
    cout << ans << endl;
    return 0;
}

const int MAXN = 21;
unsigned long long dp[MAXN][MAXN];
int main(void)
{
    dp[0][0] = 1;
    // init
    for(int i = 1; i < MAXN; ++i)
    {
        dp[i][0] = dp[i-1][0];
        dp[0][i] = dp[0][i-1];
    }
    for(int i = 1; i < MAXN; ++i)
        for(int j = 1; j < MAXN; ++j)
            dp[i][j] = dp[i-1][j] + dp[i][j-1];
    cout << dp[MAXN-1][MAXN-1] << endl;

    return 0;
}

int main(void)
{
    long long mo = 1LL;
    long long de = 1LL;
    for(int i = 1; i <= 10; ++i)
    {
        mo *= 19 + (i * 2);
        de *= i;
        long long tmp = gcd(mo,de);
        mo /= tmp;
        de /= tmp;
    }
    long long ans = mo * 1024 / de;
    cout << ans;
    return 0;

}

long long SumOf(long long up, int k)
{
    long long cnt = (up - 1) / k;
    return (k + cnt * k) * cnt / 2;
}
int main()
{
    long long n;
    cin >> n;
    cout << SumOf(n, 5) + SumOf(n, 7) - SumOf(n, 35) << endl;
    return 0;
}

int main()
{
    int ans = 0;
    int a = 1, b = 1, c = 2;

    while(c <= 4000000)
    {
        ans += c;
        a = b + c;
        b = a + c;
        c = a + b;
    }

    cout << ans << endl;
}

int main()
{
    int a[3] = {2,8,34};
    int ans = 0;
    int p = 2;
    while(a[p] < 4000000)
    {
        ans += a[p];
        p = (p + 1) % 3;
        a[p] = 4 * a[(p + 2) % 3] + a[(p + 1) % 3];
    }
    cout << ans << endl;
}

int Eratosthenes()
{
    const long long TARGET = 600851475143LL;
    const int upper = static_cast<const int>(sqrt(TARGET));
    bool *num = new bool[static_cast<unsigned long long>(upper)];
    memset(num, false, sizeof(bool) * static_cast<unsigned long long>(upper));
    int ans = 2;
    for(int i = ans; i < upper; ++i)
    {
        if(num[i] == false)
        {
            int p = 2;
            while(i * p < upper)
            {
                num[ i * p ] = true;
                ++p;
            }
            if(TARGET % i == 0)
                ans = i;
        }
    }
    delete[] num;
    return ans;
}

int main(void)
{
    int ans = Eratosthenes();
    cout << ans << endl;
    return 0;
}

int main()
{
    int num;
    int mark = 1;
    for(int i = 9; i >= 1 && mark; --i)
        for(int j = 9; j >= 0 && mark; --j)
            for(int k = 9; k >= 0 && mark; --k)
            {
                num = i*100 + j * 10 + k;
                num = num * 1000 + k * 100 + j * 10 + i;
                for(int t = 999; t >= 100 && mark; --t)
                    if(num % t == 0 && num / t >= 100 && num / t < 1000)
                    {
                        cout << num << endl;
                        mark = 0;
                    }
            }
    return 0;
}

bool check(vector<int>& s, int num)
{
    for(int e : s)
        if(num % e == 0)
            return false;
    return true;
}
int main(void)
{
    vector<int> s;
    for(int i = 2; i <= 20; ++i)
        if(check(s,i))
            s.push_back(i);
    long long ans = 1LL;
    for(int e : s)
    {
        int m = 1;
        while(m * e <= 20)
            m *= e;
        ans *= m;
    }
    cout << ans << endl;
    return 0;
}