#include <iostream>
#include <deque>
#include <vector>
#include <algorithm>

struct Interval
{
    int64_t l, r;
    bool rising;
    int timestamp;
};

int main()
{
    int64_t n, mind, maxd;
    std::cin >> n >> mind >> maxd;
    
    std::vector<int64_t> anchors(n);
    for(int64_t i=0; i<n; i++)
    {
        std::cin >> anchors[i];
    }
    
    std::sort(anchors.begin(), anchors.end());
    for(int i=0; i<n; i++)
    {
        if( (i > 0) && ((anchors[i] - anchors[i-1]) < mind))
        {
            std::cout << "-1" << std::endl;
            return 0;
        }
    }
    for(int i=0; i<n; i++)
    {
        anchors[i] = 2LL * anchors[i];
    }
    
    std::deque<Interval> intervals;
    intervals.push_back({0, maxd, true, 0});
    
    int64_t leftval = 0;
    int64_t rightval = maxd;
    
    for(int i=1; i<n; i++)
    {
        int64_t gap = anchors[i] - anchors[i-1];
        if((i % 2) == 1)
        {
            int64_t origin = intervals.front().l;
            
            while(intervals.back().l - origin > gap)
            {
                bool parity = ((i-intervals.back().timestamp) % 2) == 0;
                if(parity ^ intervals.back().rising)
                    rightval -= intervals.back().r - intervals.back().l;                
                intervals.pop_back();
            }
            if(intervals.back().r - origin >= gap)
            {
                bool parity = ((i-intervals.back().timestamp) % 2) == 0;
                if(parity ^ intervals.back().rising)
                    rightval -= intervals.back().r - origin - gap;
                intervals.back().r = gap + origin;
            }
            else
                intervals.push_back({intervals.back().r, gap+origin, true, i});
                
            leftval += intervals.back().r - intervals.front().l;
        }
        else
        {
            int64_t origin = intervals.back().r;
            while(origin - intervals.front().r > gap)
            {
                bool parity = ((i-intervals.front().timestamp) % 2) == 0;
                if(parity ^ intervals.front().rising)
                    leftval -= intervals.front().r - intervals.front().l;
                intervals.pop_front();
            }
            if(origin - intervals.front().l > gap)
            {
                bool parity = ((i-intervals.front().timestamp) % 2) == 0;
                if(parity ^ intervals.front().rising)
                    leftval -= origin - gap - intervals.front().l;
                intervals.front().l = origin - gap;
            }
            else
                intervals.push_front({origin-gap, intervals.front().l, true, i});
                
            rightval += intervals.back().r - intervals.front().l;
        }
        
        int64_t extent = std::min(gap-mind, maxd);
        
        if((i % 2) == 0)
        {
            int64_t origin = intervals.front().l;
            while(intervals.back().l - origin > extent)
            {
                bool parity = ((i-intervals.back().timestamp) % 2) == 1;
                if(parity ^ intervals.back().rising)
                    rightval -= intervals.back().r - intervals.back().l;                
                intervals.pop_back();
            }
            if(intervals.back().r - origin >= extent)
            {
                bool parity = ((i-intervals.back().timestamp) % 2) == 1;
                if(parity ^ intervals.back().rising)
                    rightval -= intervals.back().r - origin - extent;
                intervals.back().r = extent + origin;
            }
            else
            {
                intervals.push_back({intervals.back().r, extent+origin, true, i});            
                rightval += extent+origin-intervals.back().r;
            }
        }
        else
        {
            int64_t origin = intervals.back().r;
            while(origin - intervals.front().r > extent)
            {
                bool parity = ((i-intervals.front().timestamp) % 2) == 1;
                if(parity ^ intervals.front().rising)
                    leftval -= intervals.front().r - intervals.front().l;
                intervals.pop_front();
            }
            if(origin - intervals.front().l >= extent)
            {
                bool parity = ((i-intervals.front().timestamp) % 2) == 1;
                if(parity ^ intervals.front().rising)
                    leftval -= origin - extent - intervals.front().l;
                intervals.front().l = origin - extent;
            }
            else
            {
                intervals.push_front({origin-extent, intervals.front().l, true, i});
                leftval += intervals.front().l - origin + extent;
            }
        }
    }
        
    
    std::cout << std::max(rightval,leftval) << std::endl;
}