#include <cmath>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
typedef unsigned long long ull;

void factor(const vector<ull>& primes, ull n,
            vector<pair<ull, int>>& factorization) {
  while (n > 1) {
    bool broke_out = false;
    for (ull p : primes) {
      if (p * p > n) {
        broke_out = true;
        break;
      }
      if (n % p == 0) {
        n /= p;
        int expo = 1;
        while (n % p == 0) {
          n /= p;
          expo++;
        }
        factorization.push_back(make_pair(p, expo));
      }
    }
    if (broke_out && n > 1) {
      factorization.push_back(make_pair(n, 1));
      break;
    }
  }
}

void calc_sigma(const vector<pair<ull, int>>& factorization, int index, ull div,
                ull& sigma) {
  if (index == factorization.size()) {
    sigma += div;
    return;
  }

  for (int i = 0; i <= factorization[index].second; i++) {
    calc_sigma(factorization, index + 1, div, sigma);
    div *= factorization[index].first;
  }
}

void sieve(ull MAX, vector<ull>& sigmas) {
  vector<ull> primes;
  vector<bool> is_prime(MAX, true);
  for (ull n = 2; n < MAX; n++) {
    if (is_prime[n]) {
      primes.push_back(n);
      for (ull i = 2 * n; i < MAX; i += n) {
        is_prime[i] = false;
      }
    }
  }

  sigmas.push_back(0);  // dummy filler for 0-indexed array
  for (ull n = 1; n < MAX; n++) {
    vector<pair<ull, int>> factorization;
    factor(primes, n, factorization);
    ull sigma = 0;
    calc_sigma(factorization, 0, 1, sigma);
    sigmas.push_back(sigma);
  }
}

// Usage: a.out 10000000
int main(int argc, char* argv[]) {
  // Empirical threshold so that the last term we trust to be part of the
  // sequence is 1441440 (ratio: 1.72774)
  double THRESHOLD = 1.72770;
  stringstream s(argv[1]);
  ull MAX;
  s >> MAX;
  vector<ull> sigma;
  sieve(MAX, sigma);
  vector<double> ratios;
  ratios.push_back(0);  // dummy filler for n = 0
  ratios.push_back(0);  // dummy filler for n = 1
  for (ull n = 2; n <= MAX; n++) {
    double ratio = sigma[n] / (n * log(log(n)));
    ratios.push_back(ratio);
  }
  double highest_ratio = 0.0;
  vector<pair<ull, double>> results;
  for (ull n = MAX-1; n >= 1; n--) {
    if (ratios[n] > highest_ratio) {
      if (ratios[n] > THRESHOLD) {
        results.push_back(make_pair(n, ratios[n]));
      }
      highest_ratio = ratios[n];
    }
  }
  for (int i = results.size() - 1; i >= 0; i--) {
    cout << results[i].first << " (ratio: " << results[i].second << ")\n";
  }
}