For this Question: Given two integers a and b. Your task is to find the sum of all the even divisors of each number from a to b inclusive.The input contains two integers a and b.

<b>Constraints:-</b>
1 &le; a &le; b &le; 10<sup>8</sup>Print the sum of even divisors.Sample Input 1:-
1 10

Sample Output 1:-
42

Sample Input 2:-
1 20

Sample Output 2:-
174

<b>Explanation:</b>
Even divisors for 1:- NIL
Even divisors for 2:- 2
Even divisors for 3:- NIL
Even divisors for 4:- 2, 4
Even divisors for 5:- NIL
Even divisors for 6:- 2,6
Even divisors for 7:- NIL
Even divisors for 8:- 2, 4, 8
Even divisors for 9:- NIL
Even divisors for 10:- 2,10
Total :- 2+2+4+2+6+2+4+8+2+10 = 42, I have written this Solution Code: // #include <bits/stdc++.h>
// using namespace std;
// long long int mod=1e9+7;
// #define inf INT_MAX
// #define f first
// #define s second
// #define psb push_back
// #define ppb pop_back
// #define psf push_front
// #define ppf pop_front
// #define umap unordered_map
// #define uset unordered_set
// typedef long long int ll;
// typedef long double ld;
// typedef pair<int,int> pi;
// typedef pair<long long int,long long int> pll;
// typedef vector<pair<int,int>> vpi;
// typedef vector<pair<long long int,long long int>> vpll;
// typedef vector<int> vi;
// typedef vector<vector<int>> vvi;
// typedef vector<vector<pair<int,int>>> vvpi;
// typedef vector<long long int> vll;
// typedef vector<string> vs;
// typedef vector<vector<long long int>> vvll;
// typedef vector<vector<vector<int>>> vvvi;
// typedef vector<vector<vector<long long int>>> vvvll;
// typedef vector<vector<pair<long long int,long long int>>> vvpll;
// typedef unsigned int ui;
// typedef unsigned long long int ull;
// ll long_max=((unsigned ll)1<<63)-1;
// int int_max=INT_MAX;

// ll powm(ll x,ll y){
//     if(x==1||x==0) return x;
//     if(y==0) return 1;
//     if(y==1) return x;
//     ll ans=powm(x,y/2);
//     ans=(ans*ans)%mod;
//     if(y%2==1){
//         ans=(ans*x)%mod;
//     }
//     return ans;
// }
// vvll matmul(vvll &x,vvll &y){
//     int n=x.size();
//     vvll ans=x;
//     for(int i=0;i<n;i++){
//         for(int j=0;j<n;j++){
//             ans[i][j]=0;
//             for(int k=0;k<n;k++){
//                 ans[i][j]+=x[i][k]*y[k][j];
//                 ans[i][j]%=mod;
//             }
//         }
//     }
//     return ans;
// }
// vvll matexp(vvll &x,ll y){
//     // if(x==1||x==0) return x;
//     // if(y==0) return 1;
//     if(y==1) return x;
//     vvll ans=matexp(x,y/2);
//     ans=matmul(ans,ans);
//     if(y%2==1){
//         ans=matmul(ans,x);
//     }
//     return ans;
// }
// // in O(sqrt(n));
// vll factors(ll a){
//     vll ans;
//     ll i=1;
//     while(i*i<=a){
//         if(a%i==0){
//             ans.psb(i);
//             if(a/i!=i){
//                 ans.psb(a/i);
//             }

//         }
//         i++;
//     }
//     sort(ans.begin(),ans.end());
//     return ans;
// }
// // enable fac and invfac in main function to use 
// // factorial and inverse factorial vectors;
// vll fc,invfc,inv;
// void fac(int n){    
//     fc.resize(n);  
//     fc[0]=1;
//     for(int i=1;i<n;i++){
//         fc[i]=(fc[i-1]*i)%mod;
//     }
// }
// void invfac(int n){ 
//     inv.resize(n);
//     for(int i=0;i<n;i++){
//         inv[i]=powm(i,mod-2);
//     }
//     invfc.resize(n); 
//     invfc[0]=1;
//     invfc[1]=1;
//     for(int i=2;i<n;i++){
//         invfc[i]=(invfc[i-1]*inv[i])%mod;
//     }
// }
// // enable fac() and invfac() in main function to use c;
// ll ncr(int n,int r){   
//     if(r>n) return 0;
//     return (((fc[n]*invfc[r])%mod)*invfc[n-r])%mod;
// }
// ll npr(int n,int r){   
//     if(r>n) return 0;
//     return ((fc[n]*invfc[n-r])%mod)%mod;
// }

// // enable siv() in main to use vector isprime;
// vi isprime;
// vi prime;
// void siv(int n){
//     isprime.assign(n,1);
//     isprime[1]=0;
//     for(int i=2;i<n;i++){
//         if(isprime[i]==0)continue;
//         prime.psb(i);
//         int j=i;
//         while(i*(ll)j<n){
//             isprime[i*j]=0;
//             j++;
//         }
//     }
// }
// vi fps;
// void fp_sieve(int n){
//     fps.assign(n,0);
//     fps[1]=1;
//     for(int i=2;i<n;i++){
//         if(fps[i]==0){
//             fps[i]=i;
//             int j=i;
//             while(i*(ll)j<n){
//                 if(fps[i*j]==0)
//                     fps[i*j]=i;
//                 j++;
//             }
//         }
//     }
// }
// // enable fp_sieve to use this function and fps vector;
// // prime factorization in O(log(n));
// vpi pmfactors(int t){
//     vpi ans;
//     // vector using fps vector;
//     while(t!=1){
//         if(ans.size()==0||ans.back().f!=fps[t]) ans.psb({fps[t],1});
//         else ans.back().s++;
//         t/=fps[t];
//     }
//     reverse(ans.begin(),ans.end());
//     return ans;
// }
// // prime factorization in O(sqrt(n));
// vpi abs_pmfactors(int t){
//     vpi ans;
//     int i=2;
//     while(i*i<=t){
//         if(t%i==0){
//             ans.psb({i,0});
//             while(t%i==0){
//                 t/=i;
//                 ans.back().s++;
//             }
//         }
//         i++;
//     }
//     if(t!=1) ans.psb({t,1});
//     sort(ans.begin(),ans.end());
//     return ans;
// }
// ll mystoll(string &a){
//     ll ans=0,t=1;
//     while(a.size()>0){
//         ans=(a.back()-'0')*t+ans;
//         t*=10;
//         a.pop_back();
//     }
//     return ans;
// }
// string itos(ll a){
//     if(a==0) return "0";
//     string ans="";
//     bool vd=0;
//     if(a<0){
//         vd=1;
//         a*=-1;
//     }
//     while(a>0){
//         ans=(char)(a%10+'0')+ans;
//         a/=10;
//     }
//     if(vd) ans="-"+ans;
//     return ans;
// }
// bool ispal(string &a,int si,int ei){
//     // int n=a.size();
//     // int si=0,ei=n-1;
//     while(si<ei&&a[si]==a[ei]) si++,ei--;
//     if(si<ei) return 0;
//     return 1;
// }
// ll absncr(ll n,ll k){
//     if(k>n) return 0;
//     ld ans=1;
//     for(int i=1;i<=k;i++){
//         ans=ans*(n-k+i)/i;
//         ans=floor(ans+0.01);
//         ll fns=ans;
//         fns%=mod;
//         ans=fns;
//     }
//     return floor(ans+0.01);
// }
// struct llnode{
//     int val;
//     llnode* next;
//     llnode(int val){
//         this->val=val;
//         next=0;
//     }
//     ~llnode(){
//         delete this->next;
//     }
// };
// struct node{
//     ll f,s,v;
//     node(){};
//     node(ll x,ll y,ll t):f(x),s(y),v(t){}
// };

// // vpi a;
// // struct mncomp{
// //     bool operator()(const int &x,const int &y) const{
// //         if(a[x].s>a[y].s) return 1;
// //         else if(a[x].s<a[y].s) return 0;
// //         else return a[x].f<a[y].f;
// //     }
// // };
// // struct mxcomp{
// //     bool operator()(const int &x,const int &y) const{
// //         if(a[x][1]<a[y][1]) return 1;
// //         else if(a[x][1]>a[y][1]) return 0;
// //         else return a[x][2]>a[y][2];
// //     }
// // };
// struct bstcomp{
//     bool operator()(const pll &x,const pll &y) const{
//         if(x.f<y.f) return 1;
//         if(x.f>y.f) return 0;
//         return x.s<y.s;
//         // return 0;
//     }
// };
// struct comp{
//     bool operator()(const pll &x,const pll &y) const{
//         if(x.f<y.f) return 1;
//         // if(x.f<y.f) return 0;
//         // return x.s<y.s;
//         return 0;
//     }
// };

// // // int n,m;
// vvi ed,up;
// vi vd;
// // // vi x,pt,rs;
// // // vll val,vd,ct,sum,pt,dt;
// // // vpi dpg,dpb;
// void dfs(int curr,int pnt){
//     // up[curr][0]=pnt;
//     // int i=1;
//     // while(up[curr][i-1]!=-1){
//     //     up[curr][i]=up[up[curr][i-1]][i-1];
//     //     i++;
//     //     if(i>up[0].size())break;
//     // }
//     // dt[curr]=dpt;
//     for(int i=0;i<ed[curr].size();i++){
//         int cd=ed[curr][i];
//         int vl=up[curr][i];
//         if(cd==pnt) continue;
//         if(vl==0){
//             vd.psb(cd);
//         }
//         // cout<<"ff";
//         dfs(cd,curr);
//     }
// }


// /******************** code starts from here ***************************/

// void solve(){

// }

// // C:\Users\my\AppData\Roaming\Sublime Text 3\Packages\User
// int main(){
//     // #ifndef ONLINE_JUDGE
//  //    // for getting input from input.txt
//  //    freopen("input.txt", "r", stdin);
//  //    // for writing output to output.txt
//  //    freopen("output.txt", "w", stdout);
//  //    #endif
//     ios_base::sync_with_stdio(false);
//     cin.tie(0);
//     cout.tie(0);  
//     // fac(1e6+1);  
//     // invfac(1e6+1); 
//     // siv(1e5+1);
//     // fp_sieve(2e5+1);
//     // for(int i=1;i<=3000;i++){
//     //     string x;
//     //     ll f=fun(i,x);
//     //     mp[i][x]=f;
//     // }
//     int t=1;
//     cin>>t; 
//     int ct=1;
//     while(t--){ 
//         // cout<<"Case #"<<ct++<<": ";
//         solve();
//     }
//     return 0;
// }   


#include <bits/stdc++.h>
using namespace std;
#define int long long

int solve(int a,int b){
    int ans=0;
    for(int i=2;i<=b;i+=2){
        int t=b/i;
        t-=(a-1)/i;
        ans+=t*i;
    }
    return ans;
}

signed main(){
    int t;
    t=1;
    while(t--){
        int a,b;
        cin>>a>>b;
        int ans = solve(a,b);
        cout<<ans<<endl;}


    }
, In this Programming Language: C++, Now tell me if this Code is compilable or not?