struct BIT{
    int n;
    vl bit;
    void init(int N){
        n=N;
        bit.resize(n);
    }
    void upd(int i, int val){
        for(int x=i;x<n;x+=x&-x){
            bit[x]+=val;
        }
    }
    void reset(){
        For(i,n)bit[i]=0;
    }
    ll sum(int x){
        ll ret=0;
        for(int i=x;i>0;i-=i&-i){
            ret+=bit[i];
        }
        return ret;
    }
};

int n,k;
vi a[MX];
ll mnsum=0;
map<int,int> m;
BIT bit;

void reset(){
    For(i,n+5)bit.bit[i]=0;
}

ll findAns(ll val){
    ll cnt=1,cval=0, room=val-mnsum;
    vi p(n,0), b[n];//at p is 0
    For(i,n)b[i]=a[i];//by reference?
    bit.reset();
    BIT bit2;bit2.init(n+5);
    priority_queue<pi,vpi,greater<pi>> pq;

    For(i,n){
        FOR(j,1,sz(a[i])){
            if(a[i][j]<=room){
                cnt++;
                cval+=a[i][j];
            }
            bit.upd(m[a[i][j]],1);
            bit2.upd(m[a[i][j]],a[i][j]);
        }
        pq.push(mp(a[i][1],i));
    }
    while(!pq.empty() && cnt<=k && room>=0){
        pi x=pq.top();pq.pop();
        int i=x.s;p[i]++;
        cval+=x.f*(k-cnt);
        bit.upd(m[b[i][p[i]]],-1);
        bit2.upd(m[b[i][p[i]]],-b[i][p[i]]);
        FOR(j,p[i]+1,sz(b[i])){
            bit.upd(m[b[i][j]],-1);
            bit2.upd(m[b[i][j]],-b[i][j]);
            b[i][j]-=b[i][p[i]];
        }
        if(p[i]<sz(b[i])-1)
            pq.push(mp(b[i][p[i]+1],i));
        room-=b[i][p[i]];if(room<0)break;
        cnt+=bit.sum((--m.ub(room))->s);
        cval+=bit2.sum((--m.ub(room))->s);
        FOR(j,p[i]+1,sz(b[i])){
            bit.upd(m[b[i][j]],1);
            bit2.upd(m[b[i][j]],b[i][j]);
        }
        dbg("X");
    }
    return cval;
}
//ctrl f for a in works
//everyting coord compressed
//arrow operation
ll works(ll val){
    ll cnt=1, room=val-mnsum;
    vi p(n,0), b[n];//at p is finished
    For(i,n)b[i]=a[i];//by reference?
    priority_queue<pi,vpi,greater<pi>> pq;
    bit.reset();
    For(i,n){
        FOR(j,1,sz(a[i])){
            if(a[i][j]<=room)cnt++;
            bit.upd(m[a[i][j]],1);
        }
        pq.push(mp(a[i][1],i));
    }
    while(!pq.empty() && cnt<=k && room>=0){
        pi x=pq.top();pq.pop();
        int i=x.s;p[i]++;
        bit.upd(m[b[i][p[i]]],-1);
        FOR(j,p[i]+1,sz(b[i])){
            bit.upd(m[b[i][j]],-1);
            b[i][j]-=b[i][p[i]];
        }
        if(p[i]<sz(b[i])-1)
            pq.push(mp(b[i][p[i]+1],i));
        room-=b[i][p[i]];if(room<0)break;
        cnt+=bit.sum((--m.ub(room))->s);
        FOR(j,p[i]+1,sz(b[i])){
            bit.upd(m[b[i][j]],1);
        }
    }
    return cnt;
}

void solve(){
    re(n,k);
    bit.init(n+5);
    For(i,n){
        int x;re(x);
        a[i].resize(x);re(a[i]);
        sort(all(a[i]));
        mnsum+=a[i][0];
        FOR(j,1,sz(a[i]))a[i][j]-=a[i][0];a[i][0]=0;
        For(j,sz(a[i]))FOR(k,j+1,sz(a[i]))m[a[i][k]-a[i][j]]=1;
        //5e6 map operations
    }
    m[0]=1;int con=1;
    trav(x,m){
        m[x.f]=con++;
    }
    ll l=mnsum, r=INF;
    while(l!=r){
        ll mid=(l+r)/2;
        if(works(mid)>=k)r=mid;
        else l=mid+1;
    }
    ll cnt=works(l);
    ll ret=findAns(l);
    ret-=(cnt-k)*l;
    ret+=mnsum*k;
    ps(ret);
}

int main() {
        setIO();
        int t=1;
        // re(t);
        while(t--)solve();
        // you should actually read the stuff at the bottom
}

//psums, bsearch, two pointers
/* stuff you should look for
        * int overflow, array bounds
        * special cases (n=1?)
        * think of simple solution first
        * do smth instead of nothing and stay organized
        * WRITE STUFF DOWN
        * DON'T GET STUCK ON ONE APPROACH
*/