import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Euler754 {
    static final long kMod = 1000000007L;
    static final long kPhiMod = kMod - 1L;

    static long modPow(long base, long exp) {
        long result = 1L;
        long b = base % kMod;
        long e = exp;
        while (e > 0L) {
            if ((e & 1L) != 0L) {
                result = (result * b) % kMod;
            }
            b = (b * b) % kMod;
            e >>= 1L;
        }
        return result;
    }

    static byte[] mobiusUpTo(int n) {
        byte[] mu = new byte[n + 1];
        byte[] isComposite = new byte[n + 1];
        List<Integer> primes = new ArrayList<>(n / 10);

        mu[1] = 1;
        for (int i = 2; i <= n; ++i) {
            if (isComposite[i] == 0) {
                primes.add(i);
                mu[i] = -1;
            }
            for (int p : primes) {
                long v = (long) i * p;
                if (v > n) {
                    break;
                }
                isComposite[(int) v] = 1;
                if (i % p == 0) {
                    mu[(int) v] = 0;
                    break;
                }
                mu[(int) v] = (byte) -mu[i];
            }
        }
        return mu;
    }

    static class Range {
        int l, r, q;

        Range(int l, int r, int q) {
            this.l = l;
            this.r = r;
            this.q = q;
        }
    }

    static String GMod(int n) {
        byte[] mu = mobiusUpTo(n);

        List<Range> ranges = new ArrayList<>();
        List<Integer> neededKList = new ArrayList<>();
        neededKList.add(0);

        for (int l = 1; l <= n;) {
            int q = n / l;
            int r = n / q;
            ranges.add(new Range(l, r, q));
            neededKList.add(q - 1);
            l = r + 1;
        }

        Collections.sort(neededKList);
        List<Integer> uniqueNeededK = new ArrayList<>();
        for (int k : neededKList) {
            if (uniqueNeededK.isEmpty() || !uniqueNeededK.get(uniqueNeededK.size() - 1).equals(k)) {
                uniqueNeededK.add(k);
            }
        }

        Map<Integer, Integer> idx = new HashMap<>(uniqueNeededK.size() * 2);
        for (int i = 0; i < uniqueNeededK.size(); ++i) {
            idx.put(uniqueNeededK.get(i), i);
        }

        long[] superfacValue = new long[uniqueNeededK.size()];
        superfacValue[idx.get(0)] = 1L;

        int maxK = uniqueNeededK.get(uniqueNeededK.size() - 1);
        long fact = 1L;
        long superfac = 1L;
        int ptr = 0;
        if (uniqueNeededK.get(ptr) == 0) {
            ptr++;
        }

        for (int t = 1; t <= maxK; ++t) {
            fact = (fact * t) % kMod;
            superfac = (superfac * fact) % kMod;
            if (ptr < uniqueNeededK.size() && uniqueNeededK.get(ptr) == t) {
                superfacValue[ptr] = superfac;
                ptr++;
            }
        }

        long answer = 1L;

        for (Range rg : ranges) {
            long q = rg.q;
            long f = ((q * (q - 1L)) / 2L) % kPhiMod;

            long prodPos = 1L;
            long prodNeg = 1L;
            long sumMu = 0;

            for (int d = rg.l; d <= rg.r; ++d) {
                byte m = mu[d];
                if (m == 0)
                    continue;

                sumMu += m;
                if (m > 0) {
                    prodPos = (prodPos * d) % kMod;
                } else {
                    prodNeg = (prodNeg * d) % kMod;
                }
            }

            if (f != 0L) {
                answer = (answer * modPow(prodPos, f)) % kMod;
                answer = (answer * modPow(prodNeg, (kPhiMod - f) % kPhiMod)) % kMod;
            }

            long expSf = sumMu % kPhiMod;
            if (expSf < 0) {
                expSf += kPhiMod;
            }
            int key = rg.q - 1;
            int kIndex = idx.get(key);
            long sf = superfacValue[kIndex];
            answer = (answer * modPow(sf, expSf)) % kMod;
        }

        return Long.toString(answer);
    }

    public static String solve() {
        return GMod(100000000);
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}