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

public class Euler619 {
    static final long MOD = 1000000007L;

    static int[] sieveSpf(int n) {
        int[] spf = new int[n + 1];
        for (int i = 2; i <= n; i++) {
            if (spf[i] == 0) {
                spf[i] = i;
                if ((long) i * i <= n) {
                    for (long j = (long) i * i; j <= n; j += i) {
                        if (spf[(int) j] == 0) {
                            spf[(int) j] = i;
                        }
                    }
                }
            }
        }
        spf[1] = 1;
        return spf;
    }

    static List<Integer> listPrimesFromSpf(int[] spf) {
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i < spf.length; i++) {
            if (spf[i] == i)
                primes.add(i);
        }
        return primes;
    }

    static long modPow(long a, long e, long mod) {
        long r = 1 % mod;
        a %= mod;
        while (e > 0) {
            if ((e & 1) == 1)
                r = (r * a) % mod;
            a = (a * a) % mod;
            e >>= 1;
        }
        return r;
    }

    static List<Integer> xorInplace(List<Integer> v, List<Integer> b) {
        List<Integer> tmp = new ArrayList<>(v.size() + b.size());
        int i = 0, j = 0;
        while (i < v.size() || j < b.size()) {
            if (j == b.size() || (i < v.size() && v.get(i) < b.get(j))) {
                tmp.add(v.get(i++));
            } else if (i == v.size() || b.get(j) < v.get(i)) {
                tmp.add(b.get(j++));
            } else {
                i++;
                j++;
            }
        }
        return tmp;
    }

    static int rankSquarefreeVectors(int a, int b, int[] spf, int[] primeId, int numPrimes) {
        List<List<Integer>> basis = new ArrayList<>(numPrimes);
        for (int i = 0; i < numPrimes; i++) {
            basis.add(new ArrayList<>());
        }

        int rank = 0;
        for (int x = a; x <= b; x++) {
            int n = x;
            List<Integer> v = new ArrayList<>();
            while (n > 1) {
                int p = spf[n];
                int cnt = 0;
                while (n % p == 0) {
                    n /= p;
                    cnt ^= 1;
                }
                if (cnt != 0) {
                    v.add(primeId[p]);
                }
            }
            Collections.sort(v);

            while (!v.isEmpty()) {
                int piv = v.get(v.size() - 1);
                if (basis.get(piv).isEmpty()) {
                    basis.set(piv, new ArrayList<>(v));
                    rank++;
                    break;
                }
                v = xorInplace(v, basis.get(piv));
            }
        }
        return rank;
    }

    static long cMod(int a, int b, int[] spf, int[] primeId, int numPrimes, long mod) {
        int n = b - a + 1;
        int r = rankSquarefreeVectors(a, b, spf, primeId, numPrimes);
        int nullity = n - r;
        long total = modPow(2, nullity, mod);
        return (total + mod - 1) % mod;
    }

    public static String solve() {
        int A = 1000000;
        int B = 1234567;

        int[] spf = sieveSpf(B);
        List<Integer> primes = listPrimesFromSpf(spf);
        int P = primes.size();

        int[] primeId = new int[B + 1];
        Arrays.fill(primeId, -1);
        for (int i = 0; i < P; i++) {
            primeId[primes.get(i)] = i;
        }

        long ans = cMod(A, B, spf, primeId, P, MOD);
        return Long.toString(ans);
    }

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