/*
不得不說,本弱是真弱啊,這道題的思路好像不是很難,可是就是想不出。
首先將區間離散化,而後按照區間長度排序,一種暴力的方法是枚舉左區間,而後枚舉用線段樹斷定找到第一個知足條件的右區間,這樣的方法是O(n^2logn)的。
其實咱們能夠發現對於遞增的左區間來講,第一個知足條件的右區間也是遞增的,這樣複雜度就降到了O(nlogn)。
*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#define N 500010
#define inf 1000000000
using namespace std;
int b[N*2],n,m;
int mx[N*8],tag[N*8];
struct node{int l,r,len;}a[N];
bool cmp(const node&x,const node&y){return x.len<y.len;}
void push_up(int k){
mx[k]=max(mx[k*2],mx[k*2+1]);
}
void push_down(int k){
if(!tag[k]) return;
mx[k*2]+=tag[k];
tag[k*2]+=tag[k];
mx[k*2+1]+=tag[k];
tag[k*2+1]+=tag[k];
tag[k]=0;
}
void add(int k,int l,int r,int x,int y,int val){
if(l>=x&&r<=y){
mx[k]+=val;
tag[k]+=val;
return;
}
push_down(k);
int mid=l+r>>1;
if(x<=mid) add(k*2,l,mid,x,y,val);
if(y>mid) add(k*2+1,mid+1,r,x,y,val);
push_up(k);
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++){
scanf("%d%d",&a[i].l,&a[i].r);
a[i].len=a[i].r-a[i].l;
b[i*2-1]=a[i].l;
b[i*2]=a[i].r;
}
sort(b+1,b+n*2+1);
int tot=unique(b+1,b+2*n+1)-b-1;
for(int i=1;i<=n;i++){
a[i].l=lower_bound(b+1,b+tot+1,a[i].l)-b;
a[i].r=lower_bound(b+1,b+tot+1,a[i].r)-b;
}
sort(a+1,a+n+1,cmp);
int tt=1,ans=inf;
for(int i=1;i<=n;i++){
while(mx[1]<m&&tt<=n){
add(1,1,tot,a[tt].l,a[tt].r,1);
tt++;
}
if(mx[1]>=m) ans=min(ans,a[tt-1].len-a[i].len);
add(1,1,tot,a[i].l,a[i].r,-1);
}
if(ans!=inf) printf("%d",ans);
else printf("-1");
return 0;
}