#include <cstdio>
#include <algorithm>

#define LMax 1000005
#define NMax 60005
#define Buff 7000001
#define L first
#define R second

using namespace std;

int N, L, C[LMax], DP[LMax];
int S[NMax], D[LMax], DL, DR, BuffI;
pair <int, int> Int[NMax], InitInt[NMax];
char Buffer[Buff];

struct Compare
{
    inline bool operator () (const pair <int, int> &A, const pair <int, int> &B)
    {
        if (A.L<B.L)
        {
            return true;
        }
        if (A.L>B.L)
        {
            return false;
        }
        if (A.R>B.R)
        {
            return true;
        }
        return false;
    }
};

inline int ReadX()
{
    int X=0;
    while(!(Buffer[BuffI]>='0' && Buffer[BuffI]<='9'))
    {
        ++BuffI;
    }
    while(Buffer[BuffI]>='0' && Buffer[BuffI]<='9')
    {
        X=X*10+Buffer[BuffI]-'0';
        ++BuffI;
    }
    return X;
}

void Read ()
{
    freopen ("cover.in", "r", stdin);
    fread (Buffer, 1, Buff, stdin);
    N=ReadX ();
    L=ReadX ();
    for (int i=1; i<=L; ++i)
    {
        C[i]=ReadX ();
    }
    for (int i=1; i<=N; ++i)
    {
        InitInt[i].L=ReadX ();
        InitInt[i].R=ReadX ();
    }
    sort (InitInt, InitInt+N+1, Compare ());
    for (int i=0; i<=N; ++i)
    {
        while (S[0]>0 and InitInt[S[S[0]]].R>=InitInt[i].R)
        {
            --S[0];
        }
        S[++S[0]]=i;;
    }
    N=0;
    for (int i=1; i<=S[0]; ++i)
    {
        Int[N++]=InitInt[S[i]];
    }
}

void Print ()
{
    freopen ("cover.out", "w", stdout);
    printf ("%d\n", DP[L+1]);
}

inline void Pop (int &X)
{
    while (DL<=DR and D[DL]<X)
    {
        ++DL;
    }
}

inline void Push (int &X)
{
    while (DL<=DR and DP[D[DR]]>=DP[X])
    {
        --DR;
    }
    D[++DR]=X;
}

void Solve ()
{
    D[++DR]=0;
    int Prev=0;
    for (int i=1; i<=L+1; ++i)
    {
        for (; Prev+1<N and Int[Prev+1].R<i; ++Prev);
        Pop (Int[Prev].L);
        DP[i]=C[i]+DP[D[DL]];
        Push (i);
    }
}

int main()
{
    Read ();
    Solve ();
    Print ();
    return 0;
}