#include <iostream>
#include <string>
using namespace std;

string solution(string &S, string &T) {
    int n = S.size();
    int m = T.size();
    if (S == T) {
        return "NOTHING";
    }
    
    if (m == n + 1 && T.substr(0, n) == S) {
        return "ADD " + string(1, T[n]);
    }
    
    if (n == m + 1) {
        for (int i = 0; i < n - 1; i++) {
            if (S[i] == S[i + 1]) {
                string mergedS = S.substr(0, i) + S.substr(i + 1);
                if (mergedS == T) {
                    return "JOIN " + string(1, S[i]);
                }
            }
        }
    }
    
    if (n == m) {
        int first_diff = -1, second_diff = -1;
        
        for (int i = 0; i < n; ++i) {
            if (S[i] != T[i]) {
                if (first_diff == -1) {
                    first_diff = i;
                } else if (second_diff == -1) {
                    second_diff = i;
                } else {
                    return "IMPOSSIBLE";
                }
            }
        }

        if (second_diff != -1 && S[first_diff] == T[second_diff] && S[second_diff] == T[first_diff]) {
            return "SWAP " + string(1, S[first_diff]) + " " + string(1, S[second_diff]);
        }
    }
    
    return "IMPOSSIBLE";
}

import java.util.HashMap;
class Solution {
    public int solution(String S) {
        int maxLength = 0;
        for (int start = 0; start < S.length(); start++) {
            HashMap<Character, Integer> charCount = new HashMap<>();
            
            for (int end = start; end < S.length(); end++) {
                char currentChar = S.charAt(end);
                    charCount.put(currentChar, charCount.getOrDefault(currentChar, 0) + 1);

                if (allEven(charCount)) {
                    maxLength = Math.max(maxLength, end - start + 1);
                }
            }
        }

        return maxLength;
    }
    private boolean allEven(HashMap<Character, Integer> charCount) {
        for (int count : charCount.values()) {
            if (count % 2 != 0) {
                return false;
            }
        }
        return true;
    }

#include <iostream>
using namespace std;
class TreeNode {
public:
    int x; 
    TreeNode* left; 
    TreeNode* right; 

    TreeNode(int value) : x(value), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    TreeNode* solution(TreeNode* T) {
        if (!T) return nullptr; 

        if (!T->left && !T->right) {
            TreeNode* newNode = new TreeNode(T->x);
            newNode->left = new TreeNode(T->x);  
            newNode->right = new TreeNode(T->x); 
            return newNode;
        }

        if (T->left) {
            T->left = solution(T->left);
        }
        if (T->right) {
            T->right = solution(T->right);
        }

        return T;  
    }
};

#include <iostream>
#include <string>
#include <sstream>
using namespace std;
string solve(string S) {
    string protocol, hostname, fileName = "", result = "";
    stringstream output;
    size_t pos = S.find("://");
    if (pos != string::npos) {
        protocol = S.substr(0, pos);
    }

    string rest = S.substr(pos + 3);
    pos = rest.find('/');
    if (pos != string::npos) {
        hostname = rest.substr(0, pos);
        rest = rest.substr(pos + 1); 
    } else {
        hostname = rest;
        rest = "";
    }
    output << protocol << endl;
    output  << hostname << endl;
    size_t queryPos = rest.find('?');
    if (queryPos != string::npos) {
        fileName = rest.substr(0, queryPos);
        string query = rest.substr(queryPos + 1);
        if (!fileName.empty()) {
            output  << fileName << endl;
        }
        output << "Query parameters:" << endl;
        stringstream ss(query);
        string item;
        while (getline(ss, item, '&')) {
            size_t equalPos = item.find('=');
            if (equalPos != string::npos) {
                string key = item.substr(0, equalPos);
                string value = item.substr(equalPos + 1);
                output << "  " << key << ": " << value << endl;
            }
        }
    } else if (!rest.empty()) {
        output  << rest << endl;
    }

    result = output.str();
    return result;
}

def midPositiveElement(a):
    pos = [x for x in a if x > 0]
    mid = (len(pos) - 1) // 2
    return pos[mid]

#include <iostream>
#include <cmath>
using namespace std;

long long ss(long long n) {
    long long sum = 0;

    if (n % 2 == 0) {
        sum += 2; 
        while (n % 2 == 0) {
            n /= 2;
        }
    }

    for (long long i = 3; i <= sqrt(n); i += 2) {
        if (n % i == 0) {
            sum += i; 
            while (n % i == 0) {
                n /= i;
            }
        }
    }
    if (n > 1) {
        sum += n;
    }

    return sum;
}

int main() {
    long long n;
    cin >> n;
    cout << ss(n) << endl;
    return 0;
}

class UserMainCode(object):
    @classmethod
    def bestFibo(cls, input1):
        cnt = 0
        ans = 0

        for i in input1:
            if i == "H": 
                ans += 2
                cnt += 1
            else:  
                ans -= 1

            if cnt >= 3:
                break

        return ans

SELECT c.name AS Country, SUM(g.goals) AS Goals
FROM Countries c
JOIN Goals g ON c.id = g.country_id
GROUP BY c.id, c.name
ORDER BY Goals DESC, c.id ASC

long getMaxProfit(vector<int> pnl, int k) {
    int n = pnl.size();
    long maxprofit = 0;
    int i;
    long profit = 0;
    int start = 0;
    for(i=0;i<n;i++) {
        profit += pnl[i];
        if (profit <= 0) {
            profit = 0;
            start = i+1;
        } else {
            maxprofit = max(maxprofit , profit);
            if (i-start+1 == k) {
               
                profit -= pnl[start];
                start++;
            }
            while(pnl[start] <= 0 && start <=i) {
                profit -= pnl[start];
                maxprofit = max(maxprofit , profit);
                start++;
            }
        }
    }
    return maxprofit;
}