using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
class Program
{
    static void Main(string[] args)
    {
            // いろいろ考察した結果 Nの約数(1除く)とN-1の約数(1除く)それぞれの値をKとおき
            // そのKで除算減算の交換処理を行いN=1になるものを求めればそれがKの個数となると思われる。
            // 但し1兆もの値に対して 例えば 3等で除算減算してたらTimeOver必死
            // →除算で余りが0にならない時は 減算せずに剰余とする。これで解決。
            // 約数取得時に素因数分解を行うが素因数が多すぎるとTimeOver発生した為
            // 約数取得ロジックを大幅に変更。各素因数の累乗値を元に算出するようにした。
            // 今までは素因数の組み合わせで行っていた為、無駄な組み合わせが発生していた。

            // 前準備
            // 1兆の値の約数を求めるのに1から1兆まで除算して余りが0になる値を計算したらどう見てもTimeOver必死
            // 1兆の値の約数を求めるのには因数分解が必要
            // 1兆の値の因数分解する為には2 から 999983 までの素数(√1兆 = 1000000なので)が判明していれば素因数分解が出来る
            // 2から999983まので素数取得
            // 2から999983まので素数取得する為には2から997までの素数(√999983 = 999.9915なので)が判明していればOK
            int iRng = 999983;                                                                   // 調査範囲 999983まで
            List<int> lstPrm = new List<int>() { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 };
            GetPrim(ref lstPrm, iRng);

            // 入力
            string[] sS = System.Console.ReadLine().Trim().Split(' ');
            long iInpN = long.Parse(sS[0]);
            //// Debug入力
            //List<ClsCal> lstCal = new List<ClsCal>();
            //for (long i = 151; i < 1002; i++) { lstCal.Add(new ClsCal() { iN = i }); }

            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();

            // 解析
            List<long> lstFctN0 = new List<long>();                         // N  の素因数分解要素
            GetFact(lstFctN0, lstPrm, iInpN);                               // N  の素因数分解実行
            //DitFact(lstFctN0);                                              // N  の素因数分解のDistinct
            List<long> lstYakN0 = new List<long>();                         // N  の約数要素
            GetYaku2(lstYakN0, lstFctN0);                                    // N  の約数要素取得
            if (!lstYakN0.Contains(iInpN)) { lstYakN0.Add(iInpN); }         // N  の約数にNがなければ追加
            List<long> lstFctN1 = new List<long>();                         // N-1の素因数分解要素
            GetFact(lstFctN1, lstPrm, iInpN - 1);                           // N-1の素因数分解実行
            //DitFact(lstFctN1);                                              // N-1の素因数分解のDistinct
            List<long> lstYakN1 = new List<long>();                         // N-1の約数要素
            GetYaku2(lstYakN1, lstFctN1);                                    // N-1の約数要素取得
            if (!lstYakN1.Contains(iInpN - 1)) { lstYakN1.Add(iInpN - 1); } // N-1の約数にN-1がなければ追加
            List<long> lstYak = new List<long>();                           // NとN - 1の約数要素
            lstYak.AddRange(lstYakN0);
            lstYak.AddRange(lstYakN1);
            DitFact(lstYak);                                                // NとN - 1の約数要素のDistinct
            lstYak.Remove(1L);                                              // 約数1は除外
            lstYak.Remove(2L);                                              // 約数2は除外(2は必須)
            lstYak.Sort();                                                  // 約数要素のソート
            List<long> lstRet = new List<long>();                           // Kの一覧
            lstRet.Add(2L);                                                 // 2は必須
            for (int i = 0; i < lstYak.Count; i++)
            {
                long iN = iInpN;
                while (true)
                {
                    if (iN < lstYak[i]) { break; }                          // 残りがK未満で抜ける
                    if (iN % lstYak[i] == 0) { iN = iN / lstYak[i]; }       // 割り切れる  時は除算の商  に置き換える
                    else { iN = iN % lstYak[i]; }                           // 割り切れない時は剰余の余りに置き換える
                    if (iN == 1) { lstRet.Add(lstYak[i]); break; }          // 残りが1ならOK
                }
            }
            
            // 出力
            System.Console.WriteLine("{0}", lstRet.Count.ToString().Trim());

            //// 入力 検算用
            ////string[] sS = System.Console.ReadLine().Trim().Split(' ');
            ////long iN = long.Parse(sS[0]);
            //// Debug入力
            //List<ClsCal> lstCal = new List<ClsCal>();
            //for (long i = 3140; i < 3150; i++) { lstCal.Add(new ClsCal() { iN = i }); }

            //// 解析
            //for (int i = 0; i < lstCal.Count; i++)
            //{
            //    for (long iK = 2; iK <= lstCal[i].iN; iK++)
            //    {
            //        long iN = lstCal[i].iN;
            //        while (true)
            //        {
            //            if (iN < iK) { break; }
            //            if (iN % iK == 0) { iN = iN / iK; }
            //            else { iN = iN - iK; }
            //            if (iN == 1) { lstCal[i].iK.Add(iK); break; }
            //        }
            //    }
            //}

            sw.Stop();
#if DEBUG
            Console.WriteLine();
            //DebugDisp(lstCal);
            Console.WriteLine("{0}", sw.Elapsed.ToString());
            Console.WriteLine("続行するには何かキーを押してください．．．");
            Console.ReadKey();
#endif
    }

        // Debug表示
        private static void DebugDisp(List<ClsCal> lstCal)
        {
            System.Console.WriteLine("{0}", "".ToString().Trim());
            for (int i = 0; i < lstCal.Count; i++)                          // 分割後グループ毎
            {
                string sOut = "";
                //sOut += lstCal[i].iN.ToString().PadLeft(3, ' ') + "=";
                //sOut += lstCal[i].iK.Count.ToString().PadLeft(3, ' ') + ":";
                //for (int j = 0; j < lstCal[i].iK.Count; j++)
                //{
                //    sOut += lstCal[i].iK[j].ToString().PadLeft(3, ' ') + " ";
                //}
                sOut += lstCal[i].iN.ToString() + "\t";
                sOut += lstCal[i].iK.Count.ToString() + "\t";
                for (int j = 0; j < lstCal[i].iK.Count; j++)
                {
                    sOut += lstCal[i].iK[j].ToString() + "\t";
                }
                System.Console.WriteLine("{0}", sOut.ToString());
            }
        }

        // 素数算出
        private static void GetPrim(ref List<int> lstPrm, int iRng)
        {
            // 調査対象定義
            List<Boolean> lstTag = new List<Boolean>();                                         // 配列(true:素数 false:合成)
            for (int i = 0; i <= iRng / 2; i += 1) { lstTag.Add(false); lstTag.Add(true); }     // 予め 2の倍数は false にしておく

            // 調査
            lstTag[1] = false;                                                                  // 1は除外
            lstTag[2] = true;                                                                   // 2は素数
            for (int i = 1; i < lstPrm.Count; i++)                                              // 調査素数 2は除外しているので3から
            {
                int iMtS = 2;                                                                   // 例 3では100000000
                int iMtE = iRng / lstPrm[i];                                                    // 例 3では133333333
                for (int j = iMtS; j <= iMtE; j++)
                {
                    int iTmp = (int)(lstPrm[i] * j);
                    if (iTmp >= 0 && iTmp <= iRng) { lstTag[iTmp] = false; }
                }
            }
            // 結果
            List<int> lstNew = new List<int>();
            for (int i = 0; i < lstTag.Count; i++) { if (lstTag[i]) { lstNew.Add(i); } }
            lstPrm = lstNew;
        }

        // 素因数分解
        private static void GetFact(List<long> lstFct, List<int> lstPrm, long iN)
        {
            for (int i = 0; i < lstPrm.Count; i++)
            {
                if (iN < lstPrm[i]) { break; }
                while (true)
                {
                    if (iN % lstPrm[i] == 0)
                    {
                        lstFct.Add(lstPrm[i]);
                        iN = iN / lstPrm[i];
                    }
                    else { break; }
                }
            }
            if (iN != 0 && iN != 1) { lstFct.Add(iN); }                         // 最後の素数
        }

        // 素因数分解要素内をDistinctにする
        private static void DitFact(List<long> lstFct)
        {
            List<string> lstTmp = new List<string>();
            for (int i = 0; i < lstFct.Count; i++)
            {
                lstTmp.Add(lstFct[i].ToString());
            }
            lstTmp = lstTmp.Distinct().ToList();
            lstFct.Clear();
            for (int i = 0; i < lstTmp.Count; i++) { lstFct.Add(long.Parse(lstTmp[i])); }
        }

        // 素因数分解から約数取得その２(素因数の各累乗値から Nが大きくても短縮)
        private static void GetYaku2(List<long> lstYak, List<long> lstFct)
        {
            if (lstFct.Count == 0) { return; }                                                  // 素因数がなければ抜ける
            List<string> lstDeb = new List<string>();
            Dictionary<long ,int> dicPrm = new Dictionary<long, int>();                         // 素因数を同じ値の数で管理(Dictionary)
            for (int i = 0; i < lstFct .Count; i++)                                             //   A^x B^y C^z のように Aがx個 Bがy個 cがy個 で管理
            {
                if (dicPrm.ContainsKey(lstFct[i])) { dicPrm[lstFct[i]] += 1; }                  // 同じ値は+1個
                else { dicPrm.Add(lstFct[i], 1); }                                              // 初めての値は1個
            }
            List<ClsPrm> lstPrm = new List<ClsPrm>();                                           // 素因数を同じ値の数で管理(List)
            foreach (KeyValuePair<long, int> kvp in dicPrm)
            {
                lstPrm.Add(new ClsPrm() { iPrm = kvp.Key, iPow = kvp.Value, iPed = 0 });
            }
            int iPowMax = 1;                                                                    // 約数の数
            foreach (KeyValuePair<long, int> kvp in dicPrm) { iPowMax *= (kvp.Value + 1); }     // 約数の数=各素因数の累乗数+1の和
            for (int i = 0; i < iPowMax; i++)                                                   // 約数の数だけ回して約数取得計算
            {
                lstPrm[0].iPed += 1;
                for (int j = 0; j < lstPrm.Count; j++)                                          // 今回の各素因数の累乗値取得
                {
                    if (lstPrm[j].iPed > lstPrm[j].iPow)                                        // この素因数の累乗可能数より大の場合
                    {
                        lstPrm[j].iPed = 0;                                                     // この素因数の累乗は0クリアで
                        if (j + 1 < lstPrm.Count) { lstPrm[j + 1].iPed += 1; }                  // 次の素因数の累乗値を+1(次があれば)
                    }
                }
                long iRet = 1;
                for (int j = 0; j < lstPrm.Count; j++)                                          // 今回の各素因数の累乗値で約数計算
                {
                    for (int k = 0; k < lstPrm[j].iPed; k++)                                    // 今回の各素因数の累乗値だけ掛け回す 0 なら掛けない
                    {
                        iRet *= lstPrm[j].iPrm;                                                 // Math.Pow()でもいいけど doble long 型変換でオーバーフローは嫌なので
                    }
                }
                lstYak.Add(iRet);
            }
            lstYak.Sort();
        }

        // 素因数分解から約数取得(素因数の組み合わせから)
        private static void GetYaku(List<long> lstYak, List<long> lstFct)
        {
            List<string> lstDeb = new List<string>();
            int iCnt = lstFct.Count;                                                        // 素因数数
            int[] nums = new int[iCnt];
            for (int i = 0; i < iCnt; i++) { nums[i] = i; }
            for (int i = iCnt; i > 0; i--)                                                  // 取得する数 iCnt個から少なくしていく
            {
                var combinations = Combination.Enumerate(nums, i, withRepetition: false);   // 配列内の考えられる組み合わせ
                foreach (var elem in combinations)
                {
                    long iL = 1;
                    for (int j = 0; j < elem.Length; j++) { iL *= lstFct[elem[j]]; }        // ある組み合わせの積
                    lstDeb.Add(iL.ToString());                                              // それがある約数
                }
            }
            // 重複排除
            lstDeb.Sort();
            lstDeb = lstDeb.Distinct().ToList();
            for (int i = 0; i < lstDeb.Count; i++) { lstYak.Add(long.Parse(lstDeb[i])); }
            lstYak.Sort();
        }

        // N個からK個取得する組み合わせ(但しNが大きいと時間が掛かる)
        private static class Combination
        {
            public static IEnumerable<T[]> Enumerate<T>(IEnumerable<T> items, int k, bool withRepetition)
            {
                if (k == 1)
                {
                    foreach (var item in items)
                        yield return new T[] { item };
                    yield break;
                }
                foreach (var item in items)
                {
                    var leftside = new T[] { item };

                    // item よりも前のものを除く （順列と組み合わせの違い)
                    // 重複を許さないので、unusedから item そのものも取り除く
                    var unused = withRepetition ? items : items.SkipWhile(e => !e.Equals(item)).Skip(1).ToList();

                    foreach (var rightside in Enumerate(unused, k - 1, withRepetition))
                    {
                        yield return leftside.Concat(rightside).ToArray();
                    }
                }
            }
        }

        private class ClsPrm
        {
            public long iPrm { get; set; } = 0L;                        // 素数
            public int  iPow { get; set; } = 0;                         // 累乗
            public int  iPed { get; set; } = 0;                         // 累乗カウント値
            public override bool Equals(object obj)                     // 重複排除用定義 .Distinct()用
            {
                var p = obj as ClsPrm;
                if (p == null) { return false; }
                return (this.iPrm == p.iPrm);
            }
            public override int GetHashCode()                           // 重複排除用定義 .Distinct()用
            => iPrm.GetHashCode();                                      // 重複排除用定義 .Distinct()用
        }

        private class ClsCal
        {
            public long       iN { get; set; } = 0L;                    // N
            public List<long> iK { get; set; } = new List<long>();      // K
        }

}


Measured memory_bytes: 32216