int Euler(int n) {
     int res = n, a = n;
     for (int i = 2; i * i <= a; i++) {
         if (a % i == 0) {
             //trick 先进行除法防止中间数据溢出
             res = res / i * (i - 1);
             while (a % i == 0) a /= i;
         }
     }
     if(a > 1) res = res / a * (a - 1);
     return res;
}

const int maxlen = 1000010;
long long eul[maxlen] = { 0 };
int pri[maxlen] = { 0 }, f[maxlen] = { 0 }, isprim[maxlen] = { 0 }, p = 0;
inline void get_prim() {
    memset(isprim, 1, sizeof(isprim));
    for (int i = 2; i < maxlen; i++) {
        if (isprim[i]) pri[p++] = i;
        for(int j = 0; j < p && i * pri[j] < maxlen; j++) {
            int k = pri[j] * i;
            isprim[k] = 0;
            f[k] = pri[j];
            if (i % pri[j] == 0) break;
        }
    }
}
inline void get_eul() {
    for (int i = 2; i < maxlen; i++)
        if (isprim[i]) {
            eul[i] = i - 1;
        }
        else {
            int k = i / f[i];
            if (k % f[i] == 0) 
                eul[i] = eul[k] * f[i];
            else 
                eul[i] = eul[k] * (f[i] - 1);
        }
    for(int i = 3; i < maxlen; i++)
        eul[i] += eul[i - 1];
}

int main() {
    int m = 0;
    get_prim();
    get_eul();
    while (scanf("%d", &m))
        printf("%lld\n", eul[m] + 1);
}

int Ex_GCD(int a, int b, int& x, int& y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int ans = Ex_GCD(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return ans;
}

int Get(int a, int b) {
    int x = 0, y = 0;
    int gcd = Ex_GCD(a, b, x, y);
    if (1 % gcd != 0) return -1;
    x *= 1 / gcd;
    m = abs(m);
    int ans = x % m;
    if (ans < 0) ans += m;
    return ans;
}

int GCD(int m, int n) {
	while (m % n != 0) {
		int temp = m;
		m = n;
		n = temp % n;
	}
	return n;
}

bool Judge(int nNum) {
	if (nNum == 1) return false;
	for (int i = 2; i <= sqrt(nNum); i++) {
		if (nNum % i == 0) return false;
	}
	return true;
}

#include <iostream>
using namespace std;
const long N = 200000;
long prime[N] = { 0 }, num_prime = 0;
int isNotPrime[N] = { 1 };
int main() {
        for (long i = 2; i < N; i++) {
        if (!isNotPrime[i])
        	prime[num_prime++] = i;
        for (long j = 0 ; j < num_prime && i * prime[j] <  N; j++) {
                isNotPrime[i * prime[j]] = 1;
            if (!(i % prime[j]))
                break;
        }
    }
    for (int i = 0; i < num_prime; i++) printf("%d ", prime[i]);
    return 0;
}

long long PowerMod(int m, int n, int p) {
	long long ans = 1;
	while (n > 0) {
		if (n & 1) {
			ans *= m;
			ans %= p;
		}
		m *= m;
		n >>= 1;
		m %= p;
	}
	return ans;
}

#include <iostream>
#include <list>
#include <queue>
using namespace std;

class Graph {
	int V;             // 顶点个数
	list<int> *adj;    // 邻接表
	queue<int> q;      // 维护一个入度为0的顶点的集合
	int* indegree;     // 记录每个顶点的入度
public:
	Graph(int V);                   // 构造函数
	~Graph();                       // 析构函数
	void addEdge(int v, int w);     // 添加边
	bool topological_sort();        // 拓扑排序
};

Graph::Graph(int V) {
	this->V = V;
	adj = new list<int>[V];
	indegree = new int[V];           
	for(int i = 0; i < V; i++)       // 入度全部初始化为0
		indegree[i] = 0;
}
Graph::~Graph() {
	delete [] adj;
	delete [] indegree;
}

void Graph::addEdge(int v, int w) {
	adj[v].push_back(w);
	indegree[w] ++;
}

bool Graph::topological_sort() {
	for (int i = 0; i < V; i++)
		if(indegree[i] == 0)
			q.push(i);         // 将所有入度为0的顶点入队

	int count = 0;             // 计数，记录当前已经输出的顶点数 
	while (!q.empty()) {
		int v = q.front();      // 从队列中取出一个顶点
		q.pop();

		cout << v << " ";      // 输出该顶点
		count ++;
		// 将所有v指向的顶点的入度减1，并将入度减为0的顶点入栈
		list<int>::iterator beg;
		for (beg = adj[v].begin(); beg != adj[v].end(); beg++)
			if ((--indegree[*beg]) == 0)
				q.push(*beg);   // 若入度为0，则入队
	}

	if(count < V)
		return false;           // 没有输出全部顶点, 有向图中有回路
	else
		return true;            // 拓扑排序成功
}

//左图 & 右图
int n = 0, m = 0;
int Belong[1001] = { 0 };
int line[1001][1001] = { 0 };
bool used[1001] = { false };

bool find (int nPoint) {
    for (int j = 1; j <= m; j++) {
        if (line[nPoint][j] && !used[j]) {
			used[j] = true;
            if (Belong[j] == 0 || find(Belong[j])) {   
                Belong[j] = nPoint;
                return true;
            }
		}
    }  
    return false;  
}

for (int i = 1; i <= n; i++) {
    memset(used, 0, sizeof(used));
    if(find(i)) all += 1;
}

bool DFS(int nPoint) {
	for (int i = head[nPoint]; i != 0; i = EDGE[i].nPre) {
		int nNextPoint = EDGE[i].nTo;
		if (Is[nNextPoint]) continue;
		Is[nNextPoint] = true;
		if (nLink[nNextPoint] == 0 || DFS(nLink[nNextPoint])) {
			nLink[nNextPoint] = nPoint;
			return true;
		}
	}
	return false;
}

int DFN[MAX_N] = { 0 };
int LOW[MAX_N] = { 0 };
int nIndex = 0;
stack<int> S;
bitset<MAX_N> Is;
inline void Tarjan(int nPoint) {
	nIndex ++;
	DFN[nPoint] = LOW[nPoint] = nIndex;
	S.push(nPoint);
	Is[nPoint] = 1;
	for (int i = head[nPoint]; i != 0; i = EDGE[i].nPre) {
		int nNextPoint = EDGE[i].nTo;
		if (DFN[nNextPoint] == 0) {
			Tarjan(nNextPoint);
			LOW[nPoint] = min(LOW[nPoint], LOW[nNextPoint]);
		}
		else if (Is[nNextPoint] == 1){
			LOW[nPoint] = min(LOW[nPoint], DFN[nNextPoint]);
		}
	}
	//根据实际情况处理
	if (DFN[nPoint] == LOW[nPoint]) {
		int temp = 0;
		CC ++;
		do {
			temp = S.top(); S.pop();
			Arr[CC].push_back(temp);
			Is[temp] = 0;
		} while (temp != nPoint);
		
		nMax_size = max(nMax_size, (int)Arr[CC].size());
	}
}

struct STRUCT {
    int Num_1;
    int Num_2;
    int Num_3;
}

//按照 Num_1 Num_2 Num_3 关键字的顺序从小到大排序, 当然也可以按照其他关键字排序, 比如 当 Num_1 相等的时候, Num_2 按照从大到小排序
int comp(const STRUCT A, const STRUCT B) {
    if (A.Num_1 < B.Num_1) return 1;
    if (A.Num_1 > B.Num_1) return 0;
    if (A.Num_2 < B.Num_2) return 1;
    if (A.Num_2 > B.Num_2) return 0;
    if (A.Num_3 < B.Num_3) return 1;
    if (A.Num_3 > B.Num_3) return 0;
    return 0;
}