//P4863 [JerryC Loves Driving](https://www.luogu.com.cn/problem/P4863)
#include <bits/stdc++.h>
#define ALL(NAME_i, BEGIN, TO) \
    int NAME_i = BEGIN;        \
    NAME_i <= TO;              \
    NAME_i++
#define SGN (nega ? -1 : 1)
typedef long long LL;
using namespace std;
LL solve(int n)
{
    LL ans = 0;
    bool nega = 1;
    for (ALL(i, 1, n))
    {
        LL a1 = 0,                                      //首项
            an = (n + 1) / i - 1,                       //末项
            cntSeq = an + 1;                            //项数
        ans += i * ((a1 + an) * cntSeq / 2) * SGN;      //先求等差数列的和
        ans += (n + 1 - (cntSeq * i)) * (an + 1) * SGN; //再计算剩下的部分
        nega = !nega;                                   //变符号
    }
    return ans;
}

LL solve_Odev(const int &n, bool odd)
{
    LL ans = 0;
    int maxColumn;
    bool nega = odd ? 1 : 0;
    for (int i = odd ? 1 : 2; i <= n; i = maxColumn + 2) //注意赋值语句为maxColumn + 2，也就是合并处理完几列后，直接跳到处理完的列后面。
    {
        //1. 怎么分奇偶，找到哪几列出现数字相同。
        LL maxNum = n / i;           //当前列能出现的最大数（或最后一项）
        maxColumn = n / maxNum;      //只能出现到这个数的最大列
        if (odd && !(maxColumn & 1)) //本来处理奇数列，但算出来最大列为偶数情况
            maxColumn--;
        if (!odd && (maxColumn & 1)) //本来处理偶数列，但算出来最大列为奇数情况
            maxColumn--;
        /* 对应于上图中，当n = 33, i = 12时：
        maxNum    = 2
        maxColumn = 16	【对应为 合并12~16列。
        */

        //2. 怎么处理计算不能合并的最后一项。
        int minCnt = (n + 1) - maxColumn * maxNum,  //首项——这几列中，最后一项出现最少的次数（为最后一列，用maxColumn）
            maxCnt = (n + 1) - i * maxNum,          //末项——这几列中，最后一项出现最多的次数（最当前列，用i）
            cntColumn = ((maxColumn - i) >> 1) + 1; //项数——合并了几列
        /* 注意的点：
        1. 总项数为n+1个，因为0也算！
        2. 不为maxNum - 1，因为0也算！【前面项的项数为((maxNum-1) - 0) / 1 + 1，即maxNum
        */
        int cntNum = ((maxCnt + minCnt) * cntColumn) >> 1; //求得关键——最后一项有多少个（高斯求和）
        ans += maxNum * cntNum * SGN;
        /* 对应于上图中，当n = 33, i = 12, maxColumn = 16时：
        minCnt    = 2		【对应为 最后一列有2项
        maxCnt    = 10		【对应为 第一列有10项
        cntColumn = 3		【对应为 合并了3列
        cntNum    = 18		【对应为 最后一项由18个
        */

        //3. 怎么处理计算合并后的等差数列。
        LL a1 = 0,           //首项
            an = maxNum - 1, //末项
            cntSeq = an + 1; //项数
        /* 以上跟O(n)方法的几乎一样。
        区别在于当这一列完全为等差数列时（不存在不为等差数列的部分）：
        O(n)方法计算等差数列和，会包括最后一项；
        O(sqrt(n))方法计算等差数列和，不会包括最后一项。
        */
        int cnt = ((i + maxColumn) * cntColumn) >> 1;   //合并后出现次数（高斯求和）
        ans += cnt * (((a1 + an) * cntSeq) >> 1) * SGN; //（高斯求和）
    }
    return ans;
}
LL solve_block(const int &n)
{
    LL ans = 0;
    ans += solve_Odev(n, 0) + solve_Odev(n, 1);
    return ans;
}

/*
LL slove_original(int A, int B)
//最原始的做法，但考虑的会更复杂所以未完成为错误的
//错误点为为考虑开始部分为非等差数列
{
    LL ans = 0;
    bool nega = 1;
    for (ALL(i, 1, B))
    {
        int seqBgeinIndex = A + max(i - A, 0), cnt = (B - seqBgeinIndex + 1) / i, seqEndIndex = seqBgeinIndex + cnt * i - 1;
        LL a1 = max(A / i, 1), an = a1 + cnt - 1;
        ans += i * ((a1 + an) * cnt / 2) * SGN;
        ans += (B - seqEndIndex) * (an + 1) * SGN;
        nega = !nega;
    }
    return ans;
}
*/
int main()
{
    int A, B;
    scanf("%d%d", &A, &B);
    //printf("%lld\n", solve(B) - solve(A - 1));
    printf("%lld", solve_block(B) - solve_block(A - 1));
}