/*

    朴素的做法：

    把k看作是k条路径，一条路径只能由不重复的区间组成，每个区间只能用一次，然后拆点跑最大费用流。

*/

#include<iostream>

#include<cstdio>

#include<algorithm>

#include<queue>

#define N 1010

#define inf 1000000000

using namespace std;

int head[N],dis[N],inq[N],fa[N],n,k,S,T,cnt=;

struct Node{int l,r;}a[N];

struct node{int v,f,w,pre;}e[N*];

queue<int> q;

void add(int u,int v,int f,int w){

    e[++cnt].v=v;e[cnt].f=f;e[cnt].w=w;e[cnt].pre=head[u];head[u]=cnt;

    e[++cnt].v=u;e[cnt].f=;e[cnt].w=-w;e[cnt].pre=head[v];head[v]=cnt;

}

bool spfa(){

    for(int i=;i<=T;i++) dis[i]=inf;

    dis[S]=;q.push(S);

    while(!q.empty()){

        int u=q.front();q.pop();inq[u]=;

        for(int i=head[u];i;i=e[i].pre)

            if(e[i].f&&dis[e[i].v]>dis[u]+e[i].w){

                dis[e[i].v]=dis[u]+e[i].w;

                fa[e[i].v]=i;

                if(!inq[e[i].v]){

                    inq[e[i].v]=;

                    q.push(e[i].v);

                }

            }

    }

    return dis[T]!=inf;

}

int updata(){

    int i=fa[T],x=inf;

    while(i){

        x=min(x,e[i].f);

        i=fa[e[i^].v];

    }

    i=fa[T];

    while(i){

        e[i].f-=x;

        e[i^].f+=x;

        i=fa[e[i^].v];

    }

    return x*dis[T];

}

bool cmp(const Node&x,const Node&y){

    if(x.l==y.l) return x.r<y.r;

    return x.l<y.l;

}

int main(){

    freopen("interv.in","r",stdin);

    freopen("interv.out","w",stdout);

    scanf("%d%d",&n,&k);

    for(int i=;i<=n;i++)

        scanf("%d%d",&a[i].l,&a[i].r);

    sort(a+,a+n+,cmp);

    S=;T=n*+;int SS=n*+;

    add(S,SS,k,);

    for(int i=;i<=n;i++){

        add(SS,i,inf,);

        add(i+n,T,inf,);

        add(i,i+n,,a[i].l-a[i].r);

    }

    for(int i=;i<=n;i++)

        for(int j=i+;j<=n;j++)

            if(a[i].r<=a[j].l) add(i+n,j,,);

    int minv=;

    while(spfa()) minv+=updata();

    printf("%d",-minv);

    return ;

}

/*

    还有一种神奇的做法：

    离散化所有区间的端点，把每个端点看做一个顶点，建立附加源S汇T。

    建图如下:

        从S到顶点1（最左边顶点）连接一条容量为K，费用为0的有向边。

        从顶点2N（最右边顶点）到T连接一条容量为K，费用为0的有向边。

        从顶点i到顶点i+1(i+1<=2N)，连接一条容量为无穷大，费用为0的有向边。

        对于每个区间[a,b]，从a对应的顶点i到b对应的顶点j连接一条容量为1，费用为区间长度的有向边。

*/

#include<iostream>

#include<cstdio>

#include<algorithm>

#include<queue>

#define N 1010

#define inf 1000000000

using namespace std;

int l[N],r[N],len[N],a[N],head[N],dis[N],inq[N],fa[N],n,k,S,T,cnt=;

struct node{int v,f,w,pre;}e[N*];

queue<int> q;

void add(int u,int v,int f,int w){

    e[++cnt].v=v;e[cnt].f=f;e[cnt].w=w;e[cnt].pre=head[u];head[u]=cnt;

    e[++cnt].v=u;e[cnt].f=;e[cnt].w=-w;e[cnt].pre=head[v];head[v]=cnt;

}

bool spfa(){

    for(int i=;i<=T;i++) dis[i]=inf;

    dis[S]=;q.push(S);

    while(!q.empty()){

        int u=q.front();q.pop();inq[u]=;

        for(int i=head[u];i;i=e[i].pre)

            if(e[i].f&&dis[e[i].v]>dis[u]+e[i].w){

                dis[e[i].v]=dis[u]+e[i].w;

                fa[e[i].v]=i;

                if(!inq[e[i].v]){

                    inq[e[i].v]=;

                    q.push(e[i].v);

                }

            }

    }

    return dis[T]!=inf;

}

int updata(){

    int i=fa[T],x=inf;

    while(i){

        x=min(x,e[i].f);

        i=fa[e[i^].v];

    }

    i=fa[T];

    while(i){

        e[i].f-=x;

        e[i^].f+=x;

        i=fa[e[i^].v];

    }

    return x*dis[T];

}

int main(){

    //freopen("interv.in","r",stdin);

    //freopen("interv.out","w",stdout);

    scanf("%d%d",&n,&k);

    for(int i=;i<=n;i++){

        scanf("%d%d",&l[i],&r[i]);

        a[i*-]=l[i];a[i*]=r[i];len[i]=r[i]-l[i];

    }

    sort(a+,a+n*+);

    for(int i=;i<=n;i++){

        l[i]=lower_bound(a+,a+n*+,l[i])-a;

        r[i]=lower_bound(a+,a+n*+,r[i])-a;

    }

    S=;T=n*+;

    add(,,k,);add(n*,T,k,);

    for(int i=;i<n*;i++) add(i,i+,inf,);

    for(int i=;i<=n;i++) add(l[i],r[i],,-len[i]);

    int minv=;

    while(spfa()) minv+=updata();

    printf("%d",-minv);

    return ;

}