#include <bits/stdc++.h>
#define NMAX 1000001
using namespace std;

vector<vector<int>> divizori_primi; ///lista divizorilor primi ai fiecarui numar
vector<int> prod_divizori; ///produsul divizorilor primi ai fiecarui numar

void eratostene() ///calculam ciurul lui eratostene
{
    bitset<NMAX/2> ciur;
    vector<int> prime; ///numerele prime pana la 1000000
    for(int i=3; i*i<NMAX; i+=2)
    {
        if(ciur[i/2]==0)
        {
            for(int j=i*i; j<NMAX; j+=2*i)
                ciur[j/2]=1;
        }
    }
    prime.push_back(2);
    for(int i=3; i<NMAX; i+=2)
    {
        if(ciur[i/2]==0)
            prime.push_back(i);
    }

    for(auto p : prime) ///calculam listele de divizori primi ale fiecarui numar
    {
        for(int d=p; d<divizori_primi.size(); d+=p)
        {
            prod_divizori[d]*=p;
            if(d%(p*p)!=0) ///daca divizorul apare o singura data
                divizori_primi[d].push_back(p); ///il adaugam la lista divizorilor
        }
    }
}

array<int, NMAX> nr_prime_cu; ///numarul de numere prime cu fiecare numar

int main()
{
    ifstream cin("mins.in");
    ofstream cout("mins.out");
    int c, d;
    cin >> c >> d;
    divizori_primi.resize(c);
    prod_divizori.resize(c, 1);
    eratostene();
    ///vom gasi numarul de perechi de numere (x, y), pentru care x<c si y<d, care sunt prime intre ele
    long long nr_drepte=0;

    for(int x=1; x<c; x++)
    {
        int produs=prod_divizori[x]; ///produsul divizorilor primi ai lui x
        if(x==produs) ///daca x este egal cu produs (adica daca fiecare divizor prim apare la puterea 1)
        {
            ///vom calcula numarul de numere prime cu x mai mici ca d folosind principiul includerii si excluderii

            int nr_d=divizori_primi[x].size(); ///numarul de divizori primi ai lui x
            for(int m=0; m<(1<<nr_d); m++)
            {
                bool adun=1; ///adunam sau scadem
                int p=1; ///produsul numerelor ai caror biti din reprezentarea in baza 2 ai lui m sunt 1
                for(int bit=0; bit<nr_d; bit++)
                {
                    if((m&(1<<bit))!=0) ///daca bitul este setat
                    {
                        adun=(!adun);
                        p*=divizori_primi[x][bit];
                    }
                }
                if(adun)
                    nr_prime_cu[x]+=(d-1)/p;
                else
                    nr_prime_cu[x]-=(d-1)/p;
            }

            nr_drepte+=nr_prime_cu[x];
        }
        else ///altfel, numarul de numere prime cu x mai mici ca d va fi egal cu numarul de numere mai mici ca d prime cu produs (care a fost deja calculat fiindca produs<x)
        {
            nr_drepte+=nr_prime_cu[produs];
            nr_prime_cu[x]=nr_prime_cu[produs];
        }
    }
    cout << nr_drepte; ///afisam numarul de drepte

    return 0;
}