import sys
from collections import defaultdict

MOD = 998244353

def factor(n):
    factors = []
    i = 2
    while i * i <= n:
        if n % i == 0:
            cnt = 0
            while n % i == 0:
                cnt += 1
                n = n // i
            factors.append((i, cnt))
        i += 1
    if n > 1:
        factors.append((n, 1))
    return factors

def main():
    N = int(sys.stdin.readline())
    if N == 1:
        print(0)
        return

    primes = factor(N)
    if not primes:
        print(0)
        return

    k = len(primes)
    divisors = []

    def backtrack(exponents, index, current_div):
        if index == k:
            divisors.append((current_div, exponents.copy()))
            return
        p, e = primes[index]
        for i in range(e + 1):
            exponents[index] = i
            backtrack(exponents, index + 1, current_div * (p ** i))

    backtrack([0]*k, 0, 1)
    divisors.sort(key=lambda x: x[0])

    d_list = [d for d, _ in divisors]
    exp_map = {d: exp for d, exp in divisors}

    # Precompute multiple_map: for each d_prev, list of d_next > d_prev and divisible
    multiple_map = defaultdict(list)
    for i in range(len(d_list)):
        d_prev = d_list[i]
        for j in range(i + 1, len(d_list)):
            d_next = d_list[j]
            if d_next % d_prev == 0:
                multiple_map[d_prev].append(d_next)

    dp = defaultdict(int)
    dp[1] = 1

    for d_prev in d_list:
        if d_prev not in dp or d_prev == d_list[-1]:
            continue
        exp_prev = exp_map[d_prev]
        for d_next in multiple_map.get(d_prev, []):
            exp_next = exp_map[d_next]

            edge_weight = 1
            for i in range(k):
                f_prev = exp_prev[i]
                f_next = exp_next[i]
                if f_next > f_prev:
                    contrib = 1
                else:
                    if f_prev == 0:
                        contrib = 1
                    else:
                        contrib = f_prev + 1
                edge_weight = (edge_weight * contrib) % MOD

            dp[d_next] = (dp[d_next] + dp[d_prev] * edge_weight) % MOD

    print(dp.get(N, 0) % MOD)

if __name__ == "__main__":
    main()