int *a = new int[50];
delete [] a;

int (*a)[50] = new int[100][50];

int **p= new int*[size];//定义指针数组 
for(int i=0;i<size;i++){
	p[i]=new int[Column];
}
for(int i=0;i<size;i++){
	delete [] p[i];
}

char *p = (char *)malloc(100); 
free(p);

%f float
%lf double
%Lf long double
sscanf("3.42","%lf",&b);     //将字符串转换为数值double

- 左对齐
0 右对齐时，用0填充左边未使用的列
+ 当一个数为正数时，前面加上一个+号
' ' 当一个数为正数时，前面加上一个空格
printf("a = %08.3Lf",a);     //右对齐，开头补零，字符宽度8位，精度3位，以long double型输出。
printf("%*d",width,num);
sprintf(buf,"%.2f",a);       //将double型数值转换为字符串

//scanf()读入char[]
char str[1024];
scanf("%[^\n]",&str);
getchar();

//getchar()读入char[]
char str[1024];
int i=0;
while((str[i]=getchar())!='\n')
    i++;
getchar();

//gets()读入char[]
char str[1024];
gets(str);

//getline()
string str;
getline(cin,str);//读入string

char str2[1024];
cin.getline(str2,1024);//读入char数组

//get()读入char[]
char str3[1024];
cin.get(str3,1024);//读入char数组
cin.get(str,1024).get();

freopen("/Users/perpeternal/Downloads/test.in", "r", stdin);	
freopen("/Users/perpeternal/Downloads/test.out", "w", stdout);

FILE *in = fopen("/Users/perpeternal/Downloads/test.in","r");
FILE *out = fopen("/Users/perpeternal/Downloads/test.out", "w");
fscanf(in,"%d",&n);
fprintf(out,"%d",n);
fclose(in);fclose(out);

void out(int count,...){
    va_list ap;  //声明一个va_list变量
	va_start(ap, count);  //第二个参数表示形参的个数
	for (int i = 0; i < count; i++) {printf("%d ",va_arg(ap, int));}
	va_end(ap);  //用于清理
}
out(4,1,2,3,4);

void out(initializer_list<int> list) {
    for (auto ptr = list.begin(); ptr != list.end(); ptr++)  printf("%d ",*ptr);
}
out({1,2,3,4});

#pragma comment(linker, “/STACK:1024000000,1024000000”)

#pragma GCC optimize (2)

#pragma GCC push_options 
#pragma GCC optimize (“O0”)
	...
#pragma GCC pop_options

//这是两个预定义类（类型），定义的变量可以用重载好的 () 运算符获取随机数
mt19937 gen(time(0)); //生成 [0, 2^32-1]
mt19937_64 gen(time(0)); //生成 [0, 2^64-1]
gen(); //生成随机数

assert(0); //终止程序，报re

int isfinite(x); 判断x是否有限，是返回1，其它返回0；
int isnormal(x); 判断x是否为一个数（非inf或nan），是返回1，其它返回0；
int isnan(x); 当x时nan返回1，其它返回0；
int isinf(x); 当x是正无穷是返回1，当x是负无穷时返回-1，其它返回0。有些编译器不区分。

bitset<4> bitset1;　　//无参构造，长度为４，默认每一位为０

bitset<8> bitset2(12);　　//长度为８，二进制保存，前面用０补充
bitset<2> bitset2(12);　　//长度为3，二进制保存，取12二进制的后两位

string s = "100101";
bitset<10> bitset3(s);　　//长度为10，前面用０补充

char s2[] = "10101";
bitset<13> bitset4(s2);　　//长度为13，前面用０补充
bitset<2> bitset5(s2)  //取s2前两位
    
//位运算
bitset<4> foo (string("1001"));
bitset<4> bar (string("0011"));

cout << (foo^=bar) << endl;       // 1010 (foo对bar按位异或后赋值给foo)
cout << (foo&=bar) << endl;       // 0010 (按位与后赋值给foo)
cout << (foo|=bar) << endl;       // 0011 (按位或后赋值给foo)

cout << (foo<<=2) << endl;        // 1100 (左移２位，低位补０，有自身赋值)
cout << (foo>>=1) << endl;        // 0110 (右移１位，高位补０，有自身赋值)

cout << (~bar) << endl;           // 1100 (按位取反)
cout << (bar<<1) << endl;         // 0110 (左移，不赋值)
cout << (bar>>1) << endl;         // 0001 (右移，不赋值)

cout << (foo==bar) << endl;       // false (0110==0011为false)
cout << (foo!=bar) << endl;       // true  (0110!=0011为true)

cout << (foo&bar) << endl;        // 0010 (按位与，不赋值)
cout << (foo|bar) << endl;        // 0111 (按位或，不赋值)
cout << (foo^bar) << endl;        // 0101 (按位异或，不赋值)

bitset<8> foo ("10011011");
cout << foo.count() << endl;　　//5　　（count函数用来求bitset中1的位数，foo中共有５个１
cout << foo.size() << endl;　　 //8　　（size函数用来求bitset的大小，一共有８位

cout << foo.test(0) << endl;　　//true　　（test函数用来查下标处的元素是０还是１，并返回false或true，此处foo[0]为１，返回true
cout << foo.test(2) << endl;　　//false　　（同理，foo[2]为０，返回false

cout << foo.any() << endl;　　//true　　（any函数检查bitset中是否有１
cout << foo.none() << endl;　　//false　　（none函数检查bitset中是否没有１
cout << foo.all() << endl;　　//false　　（all函数检查bitset中是全部为１
bitset<8> foo ("10011011");

cout << foo.flip(2) << endl;　　//10011111　　（flip函数传参数时，用于将参数位取反，本行代码将foo下标２处"反转"，即０变１，１变０
cout << foo.flip() << endl;　　 //01100000　　（flip函数不指定参数时，将bitset每一位全部取反

cout << foo.set() << endl;　　　　//11111111　　（set函数不指定参数时，将bitset的每一位全部置为１
cout << foo.set(3,0) << endl;　　//11110111　　（set函数指定两位参数时，将第一参数位的元素置为第二参数的值，本行对foo的操作相当于foo[3]=0
cout << foo.set(3) << endl;　　  //11111111　　（set函数只有一个参数时，将参数下标处置为１

cout << foo.reset(4) << endl;　　//11101111　　（reset函数传一个参数时将参数下标处置为０
cout << foo.reset() << endl;　　 //00000000　　（reset函数不传参数时将bitset的每一位全部置为０
bitset<8> foo ("10011011");

string s = foo.to_string();　　//将bitset转换成string类型
unsigned long a = foo.to_ulong();　　//将bitset转换成unsigned long类型
unsigned long long b = foo.to_ullong();　　//将bitset转换成unsigned long long类型

cout << s << endl;　　//10011011
cout << a << endl;　　//155
cout << b << endl;　　//155

//在结构体外重载结构体小于运算符
struct Time{
    int start, end;
};
bool operator <(const Time& a,const Time& b){
    return a.start > b.start;
}//只能重载小于，这里以大于重载小于是因为默认情况下，优先队列是以大的作为队首，这样一反，就可以再默认情况下使得小的作为队首

//在结构体中重载小于运算符
struct Time{
    int start, end;
    bool operator < (const Time& t)const{
        return start > t.start;
    }
};

priority_queue<Time> pq;

vector<int>v1;
vector<int>v1(v2);
vector<int>v1=v2;
vector<int> v1 = {1,2,3.0,4,5,6,7};
vector<int> v3(v1.begin()+2,v2.end()-1);
vector<int> v4(n);//初始化vector大小为n
vector<int> v5(n,x);//初始化vector为n个x

v.resize(n,x)//重置vector为n个x

struct node{  
    int x,y;  
    bool operator < (const node& t)const{  
        return x > t.x;  
    }  
};
set<node> SET;

struct cmp{
    bool operator()(const int &k1,const int &k2)const{
        return k1>k2; 
    }
};
set<int,cmp>s;

typedef struct UrlKey
{
    uint64_t dwBussID;
    uint64_t dwVersion;
    uint64_t dwHashUrl;
}UrlKey;
 
//自定义map的value
typedef struct UrlValue
{
    string strUrl;
}UrlValue;
struct cmp_key
{
    bool operator()(const UrlKey &k1, const UrlKey &k2)const
    {
        if(k1.dwBussID != k2.dwBussID)
        {
            return k1.dwBussID < k2.dwBussID;
        }
 
        if(k1.dwVersion != k2.dwVersion)
        {
            return k1.dwVersion < k2.dwVersion;
        }
        if(k1.dwHashUrl != k2.dwHashUrl)
        {
            return k1.dwHashUrl < k2.dwHashUrl;
        }
　　　　　　　　  return false;
    }
};
 
map<UrlKey, UrlValue, cmp_key> UrlMap;

struct node{
    string s;
    int step;
    node(string _s):s(_s),step(0){}
    bool operator == (const node y)const{
        return s==y.s;
    }
};
struct Hash{
    size_t operator () (const node y)const{
        return hash<string>()(y.s);
    }
};
unordered_set<node,Hash>us;

#include <iostream>
#include <set>
using namespace std;

int main()
{
   /*type of the collection:
    *-duplicates allowed
    *-elements are integral values
    *-descending order
    */
   typedef multiset<int,greater<int> > IntSet;

   IntSet coll1,        // empty multiset container

   //insert elements in random order
   coll1.insert(4);
   coll1.insert(3);
   coll1.insert(5);
   coll1.insert(l);
   coll1.insert(6);
   coll1.insert(2);
   coll1.insert(5);

   //iterate over all elements and print them
   IntSet::iterator pos;
   for (pos = coll1.begin(); pos != coll1.end(); ++pos) {
       cout << *pos << ' ';
   }
   cout << endl;

   //insert 4 again and process return value
   IntSet::iterator ipos = coll1.insert(4);
   cout << "4 inserted as element "
        << distance (coll1.begin(),ipos) + 1
        << endl;

   //assign elements to another multiset with ascending order
   multiset<int> coll2(coll1.begin(),coll1.end());

   //print all elements of the copy
   copy (coll2.begin(), coll2.end(),
         ostream_iterator<int>(cout," "));
   cout << endl;

   //remove all elements up to element with value 3
   coll2.erase (coll2.begin(), coll2.find(3));

   //remove all elements with value 5
   int num;
   num = coll2.erase (5);
   cout << num << " element(s) removed" << endl;

   //print all elements
   copy (coll2.begin(), coll2.end(),
         ostream_iterator<int>(cout," "));
   cout << endl;
}

string s(str) //拷贝构造函数 生成str的复制品
string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值
string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值
string s(cstr) //将C字符串作为s的初值
string s(chars,chars_len) //将chars字符串前chars_len个字符作为字符串s的初值。

s.assign(str); //不说
s.assign(str,1,3);//如果str是”iamangel” 就是把”ama”赋给字符串
s.assign(str,2,string::npos);//把字符串str从索引值2开始到结尾赋给s
s.assign(“gaint”); //不说
s.assign(“nico”,5);//把’n’ ‘I’ ‘c’ ‘o’ ‘\0’赋给字符串
s.assign(5,’x’);//把五个x赋给字符串

s.append(str);
s.append(str,1,3);//不解释了 同前面的函数参数assign的解释
s.append(str,2,string::npos)//不解释了
s.append(“my name is jiayp”);
s.append(“nico”,5);
s.append(5,’x’);
s.push_back(‘a’);//这个函数只能增加单个字符 对STL熟悉的理解起来很简单

s.insert(0,”my name”);
s.insert(1,str);

s.replace(1,2,”nternationalizatio”);//从索引1开始的2个替换成后面的C_string

s.erase(13);//从索引13开始往后全删除
s.erase(7,5);//从索引7开始往后删5个

s.substr();//返回s的全部内容
s.substr(11);//从索引11往后的子串
s.substr(5,6);//从索引5开始6个字符

返回符合搜索条件的字符区间内的第一个字符的索引，没找到目标就返回npos
第一个参数是被搜寻的对象。第二个参数（可有可无）指出string内的搜寻起点索引，第三个参数（可有可无）指出搜寻的字符个数。
find()
rfind() //从后向前
find_first_of()
find_last_of()
find_first_not_of()返回在字符串中首次出现的不匹配str中的任何一个字符的首字符索引, 从index开始搜索, 如果全部匹配则返回string::npos。
find_last_not_of()

s.c_str() 返回 char*

strcmp(const char *s1,const char * s2)//若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

//简单算法
//暴力枚举fib[i]%p==0的最小的i，然后记录pos=i+1，设a为fib[i]%p==0的前一位数，即a=fib[i-1]
//那么我们知道fib数列模p的最小循环节长度一定是pos*x，那么也就是说现在要求一个最小的数x，满足a^x = 1 (mod p)
bool isprime[N];
ll prime[N],primeNum;
ll gcd(ll a,ll b){
	return b?gcd(b,a%b):a;
}
void getprime(){
	ll i,j;
	memset(isprime,1,sizeof(isprime));
	primeNum=0;
	int(i=2; i<N; i++)
		if(isprime[i]){
			prime[primeNum++]=i;
			int(j=i*i; j<N; j+=i) isprime[j]=0;
		}
}
ll factor[100][2],tol;
void findfac(ll n){
	ll x=n,l=(ll)sqrt((double)n);
	tol=0;
	memset(factor,0,sizeof(factor));
	int(int i=0; prime[i]<=l; i++)
		if(x%prime[i]==0){
			factor[tol][0]=prime[i];
			while(x%prime[i]==0) {
				factor[tol][1]++;
				x/=prime[i];
			}
			tol++;
		}
	if(x>1) {
		factor[tol][0]=x;
		factor[tol++][1]++;
	}
}
ll exp_mod(ll a,ll b,ll c)
{
	ll ret=1;
	while(b)
	{
		if(b&1) ret=ret*a%c;
		b>>=1;
		a=a*a%c;
	}
	return ret;
}
ll getPrimeLoop(ll p){//求一个素数的循环节
	ll pos=3,f1=1,f2=1,f3=2%p,k=1e9,l=(ll)sqrt((double)p-1);
	while(f3) {//找到第一个值是0的点
		f1=f2;
		f2=f3;
		f3=(f1+f2)%p;
		pos++;
	}
	for(ll i=1; i<=l; i++)
		if((p-1)%i==0){
			if(exp_mod(f2,(p-1)/i,p)==1) k=min(k,(p-1)/i);
			if(exp_mod(f2,i,p)==1) k=min(k,i);
		}
	return pos*k;
}
ll solve(ll p,ll k){//求一个素数的k次方的循环节
	ll ans=getPrimeLoop(p);
	for(int i=0; i<k-1; i++) ans*=p;
	return ans;
}

//kuangbin版
//如果5是模P的二次剩余，那么循环节的的长度是 P-1 的因子，否则，循环节的长度是 2*P+1 的因子。
//对于小于等于5的素数，我们直接特殊判断，loop(2)=3,loop(3)=8,loop(5)=20。
//那么我们可以先求出所有的因子，然后用矩阵快速幂来一个一个判断，

ll gcd(ll a,ll b){
	if(b == 0)return a;
	return gcd(b,a%b);
}
ll lcm(ll a,ll b){
	return a/gcd(a,b)*b;
}
struct Matrix{
	ll mat[2][2];
};
Matrix mul_M(Matrix a,Matrix b,ll mod){
	Matrix ret;
	for(int i = 0;i < 2;i++)
		for(int j = 0;j < 2;j++){
			ret.mat[i][j] = 0;
			for(int k = 0;k < 2;k++){
				ret.mat[i][j] += a.mat[i][k]*b.mat[k][j]%mod;
				if(ret.mat[i][j] >= mod)ret.mat[i][j] -= mod;
			}
		}
	return ret;
}
Matrix pow_M(Matrix a,ll n,ll mod){
	Matrix ret;
	memset(ret.mat,0,sizeof(ret.mat));
	for(int i = 0;i < 2;i++)ret.mat[i][i] = 1;
	Matrix tmp = a;
	while(n){
		if(n&1)ret = mul_M(ret,tmp,mod);
		tmp = mul_M(tmp,tmp,mod);
		n >>= 1;
	}
	return ret;
}
ll pow_m(ll a,ll n,ll mod){//a^b % mod
	ll ret = 1;
	ll tmp = a%mod;
	while(n){
		if(n&1)ret = ret*tmp%mod;
		tmp = tmp*tmp%mod;
		n >>= 1;
	}
	return ret;
}
//素数筛选和合数分解
const int MAXN = 100000;
int prime[MAXN+1];
void getPrime(){
	memset(prime,0,sizeof(prime));
	for(int i = 2;i <= MAXN;i++){
		if(!prime[i])prime[++prime[0]] = i;
		for(int j = 1;j <= prime[0] && prime[j] <= MAXN/i;j++){
			prime[prime[j]*i] = 1;
			if(i%prime[j] == 0)break;
		}
	}
}
ll factor[100][2];
int fatCnt;
int getFactors(ll x){
	fatCnt = 0;
	ll tmp = x;
	int(int i = 1;prime[i] <= tmp/prime[i];i++){
		factor[fatCnt][1] = 0;
		if(tmp%prime[i] == 0){
			factor[fatCnt][0] = prime[i];
			while(tmp%prime[i] == 0){
				factor[fatCnt][1]++;
				tmp /= prime[i];
			}
			fatCnt++;
		}
	}
	if(tmp != 1){
		factor[fatCnt][0] = tmp;
		factor[fatCnt++][1] = 1;
	}
	return fatCnt;
}
int legendre(ll a,ll p){  //勒让德符号
	if(pow_m(a,(p-1)>>1,p) == 1)return 1;
	else return -1;
}
int f0 = 1;
int f1 = 1;
ll getFib(ll n,ll mod){
	if(mod == 1)return 0;
	Matrix A;
	A.mat[0][0] = 0;
	A.mat[1][0] = 1;
	A.mat[0][1] = 1;
	A.mat[1][1] = 1;
	Matrix B = pow_M(A,n,mod);
	ll ret = f0*B.mat[0][0] + f1*B.mat[1][0];
	return ret%mod;
}
ll fac[1000000];
ll G(ll p){
	ll num;
	if(legendre(5,p) == 1)num = p-1;
	else num = 2*(p+1);
	//找出num 的所有约数
	int cnt = 0;
	int(ll i = 1;i*i <= num;i++)
		if(num%i == 0){
			fac[cnt++] = i;
			if(i*i != num)
				fac[cnt++] = num/i;
		}
	sort(fac,fac+cnt);
	ll ans = 0;
	int(int i = 0;i < cnt;i++){
		if(getFib(fac[i],p) == f0 && getFib(fac[i]+1,p) == f1){
			ans = fac[i];
			break;
		}
	}
	return ans;
}
ll find_loop(ll n){
	getFactors(n);
	ll ans = 1;
	int(int i = 0;i < fatCnt;i++){
		ll record = 1;
		if(factor[i][0] == 2)record = 3;
		else if(factor[i][0] == 3)record = 8;
		else if(factor[i][0] == 5)record = 20;
		else record = G(factor[i][0]);
		int(int j = 1;j < factor[i][1];j++)
			record *= factor[i][0];
		ans = lcm(ans,record);
	}
	return ans;
}

int lowbit(int x){
	return x&(-x);
}

ll n,sum[N];
void add(int p,int x){ //a[p]+=x,数组为[1,n]
    while(p<=n)sum[p]+=x,p+=p&-p;
}
ll query(int p){
    ll ans = 0;
    while(p)ans+=sum[p],p-=p&-p;
    return ans;
}

int lowbit(int x){
	return x&(-x);
}
ll a[N],h[N],n;
void update(int p,int x){
  	a[p]=x;
    int lx;
    while(p<=n){
		h[p]=a[p];
        lx = lowbit(p);
		for (int i=1; i<lx; i<<=1)
			h[p] = max(h[p], h[p-i]);
		p += lowbit(p);
    }
}
int query(int l,int r){
    int ans = 0;
    while(l<=r){
      	ans = max(ans,a[r]);
      	r--;
		for(; l<=r-lowbit(r) ;r-=lowbit(r))ans = max(ans,h[r]);
    }
    return ans;
}

ll n,sum[N];
void add(int p, int x){ //这个函数用来在树状数组中直接修改
    while(p <= n) sum[p] += x, p += p & -p;
}
void range_add(int l, int r, int x){ //给区间[l, r]加上x
    add(l, x), add(r + 1, -x);
}
ll query(int p){ //单点查询
    ll res = 0;
    while(p) res += sum[p], p -= p & -p;
    return res;
}

ll sum1[N],sum2[N],n;
void add(int p, ll x){
    while(p<=n)sum1[i] += x, sum2[i] += x * p ,p+=p&-p;
}
void range_add(int l, int r, ll x){
    add(l, x), add(r + 1, -x);
}
ll query(int p){
    ll res = 0;
    while(p)res += (p + 1) * sum1[i] - sum2[i],p-=p&-p;
    return res;
}
ll range_query(int l, int r){
    return query(r) - query(l - 1);
}

void add(int x, int y, int z){ //将点(x, y)加上z
    int memo_y = y;
    while(x <= n){
        y = memo_y;
        while(y <= n)
            tree[x][y] += z, y += y & -y;
        x += x & -x;
    }
}
void ask(int x, int y){//求左上角为(1,1)右下角为(x,y) 的矩阵和
    int res = 0, memo_y = y;
    while(x){
        y = memo_y;
        while(y)
            res += tree[x][y], y -= y & -y;
        x -= x & -x;
    }
}

void add(int x, int y, int z){ 
    int memo_y = y;
    while(x <= n){
        y = memo_y;
        while(y <= n)
            tree[x][y] += z, y += y & -y;
        x += x & -x;
    }
}
void range_add(int xa, int ya, int xb, int yb, int z){
    add(xa, ya, z);
    add(xa, yb + 1, -z);
    add(xb + 1, ya, -z);
    add(xb + 1, yb + 1, z);
}
void ask(int x, int y){
    int res = 0, memo_y = y;
    while(x){
        y = memo_y;
        while(y)
            res += tree[x][y], y -= y & -y;
        x -= x & -x;
    }
}

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll read(){
    char c; bool op = 0;
    while((c = getchar()) < '0' || c > '9')
        if(c == '-') op = 1;
    ll res = c - '0';
    while((c = getchar()) >= '0' && c <= '9')
        res = res * 10 + c - '0';
    return op ? -res : res;
}
const int N = 205;
ll n, m, Q;
ll t1[N][N], t2[N][N], t3[N][N], t4[N][N];
void add(ll x, ll y, ll z){
    for(int X = x; X <= n; X += X & -X)
        for(int Y = y; Y <= m; Y += Y & -Y){
            t1[X][Y] += z;
            t2[X][Y] += z * x;
            t3[X][Y] += z * y;
            t4[X][Y] += z * x * y;
        }
}
void range_add(ll xa, ll ya, ll xb, ll yb, ll z){ //(xa, ya) 到 (xb, yb) 的矩形
    add(xa, ya, z);
    add(xa, yb + 1, -z);
    add(xb + 1, ya, -z);
    add(xb + 1, yb + 1, z);
}
ll ask(ll x, ll y){
    ll res = 0;
    for(int i = x; i; i -= i & -i)
        for(int j = y; j; j -= j & -j)
            res += (x + 1) * (y + 1) * t1[i][j]
                - (y + 1) * t2[i][j]
                - (x + 1) * t3[i][j]
                + t4[i][j];
    return res;
}
ll range_ask(ll xa, ll ya, ll xb, ll yb){
    return ask(xb, yb) - ask(xb, ya - 1) - ask(xa - 1, yb) + ask(xa - 1, ya - 1);
}
int main(){
    n = read(), m = read(), Q = read();
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            ll z = read();
            range_add(i, j, i, j, z);
        }
    }
    while(Q--){
        ll ya = read(), xa = read(), yb = read(), xb = read(), z = read(), a = read();
        if(range_ask(xa, ya, xb, yb) < z * (xb - xa + 1) * (yb - ya + 1))
            range_add(xa, ya, xb, yb, a);
    }
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++)
            printf("%lld ", range_ask(i, j, i, j));
        putchar('\n');
    }
    return 0;
}

ll dp[N][70]
void ST(int n) {
    for (int i = 1; i <= n; i++) dp[i][0] = A[i];
    for (int j = 1; (1 << j) <= n; j++) {
        for (int i = 1; i + (1 << j) - 1 <= n; i++) {
            dp[i][j] = max(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
        }
    }
}
ll RMQ(int l, int r) {
    int k = 0;
    while ((1 << (k + 1)) <= r - l + 1) k++;
    return max(dp[l][k], dp[r - (1 << k) + 1][k]);
}

int L[N],R[N],dep[N],tot;
vii node[N];
void dfs(int rt,int fa,int d){
    L[rt]=++tot;
    dep[rt]=d;
    for(int v:node[rt]){
        if(v!=fa)dfs(v,rt,d+1);
    }
    R[rt]=tot;
}

struct point{
    int x,y,id;
    oper(point){
        if(x==obj.x)return y<obj.y;
        else 
        return x<obj.x;
    }
}a[N];
int b[N];
int uni[N];
int find_root(int x){
    if (uni[x]==x) return x;
    else return uni[x]=find_root(uni[x]);
}
struct Edge{
    int u,v,w;
    oper(Edge){
        return w<obj.w;
    }
}edge[2*M];
int cnt;
void addedge(int u,int v,int w){
    edge[cnt].u=u;
    edge[cnt].v=v;
    edge[cnt++].w=w;
}
int n;
pii h[N];
void add(int p,int loc,int x,int nn){
    while(p<=nn){
        if(h[p].fi>x)h[p]=pii(x,loc);
        p+=p&-p;
    }
}
pii query(int p){
    pii mi(inf,-1);
    while(p){
        if(h[p].fi<mi.fi)mi=h[p];
        p-=p&-p;
    }
    return mi;
}
bool cmp(int a,int b){
    return a>b;
}
void fun(){
    sort(a,a+n);
    for0(i,n)b[i]=a[i].y-a[i].x;
    sort(b,b+n,cmp);
    int m=unique(b,b+n)-b;//离散化 y-x
    for(int i=1;i<=m;i++)h[i]=pii(inf,-1);
    for(int i=n-1;i>=0;i--){
        int p=upper_bound(b,b+m,a[i].y-a[i].x,cmp)-b;
        pii mi=query(p);
        if(mi.se!=-1)addedge(a[i].id,mi.se,mi.fi-a[i].y-a[i].x);
        add(p,a[i].id,a[i].y+a[i].x,m);
    }
}
int main() {
    int k;
    in(n,k);
    for0(i,n){
        in(a[i].x,a[i].y);
        a[i].id=i;
    }
    fun();
    for0(i,n)swap(a[i].x,a[i].y);
    fun();
    for0(i,n)a[i].x*=-1;
    fun();
    for0(i,n)swap(a[i].x,a[i].y);
    fun();
    sort(edge,edge+cnt);
    for0(i,n)uni[i]=i;
    int ans=0,cc=0;
    for0(i,cnt){
        int u=edge[i].u,v=edge[i].v;
        if(find_root(u)!=find_root(v)){
            cc++;
            uni[find_root(u)]=find_root(v);
            if(cc==n-k){
                ans=edge[i].w;
                break;
            }
        }
    }
    out(ans,1);
    return 0;
}

int uni[N];
int find_root(int x){
    if (uni[x]==x) return x;
    else return uni[x]=find_root(uni[x]);
}

int findMainElement(const int* array, size_t size) {
    int candidate = array[0];
    int counter = 1;
    for (int i = 1; i < size; ++i) {
        if (candidate == array[i]) {
            ++counter;
        }
        else if (counter == 1) {
            candidate == array[i];
        }
        else {
            --counter;
        }
    }
    counter = 0;
    for (int i = 0; i < size; ++i) {
        if (candidate == array[i]) {
            ++counter;
        }
    }
    if (counter * 2 > size) {
        return candidate;
    }
    else {
        return -1;
    }
}

int b=0,sum=-100000000,l,r;
for(int i=0;i<n;i++){
  	if(b>0) b=b+a[i];
  	else b=a[i];
  	if(b>sum) sum=b;
}

ll fun(ll m, ll a[], int len) {  // a的下标从1开始
    list<ll> li;
    li.push_back(0);
    ll ans = 0;
    for1(i, len) {
        while (!li.empty() && a[li.back()] > a[i]) li.pop_back();
        li.push_back(i);
        while (!li.empty() && i - li.front() > m) li.pop_front();
        ans = max(ans, a[i] - a[li.front()]);
    }
    return ans;
}

int l=1,r=0,q[N];//q[i]表示从 i 开始长度为 len 的序列中的最小值的下标
for1(i,n){
    while(i-q[l]+1>a&&l<=r)l++;
    while(a[q[r]]>a[i]&&l<=r)r--;
    q[++r]=i;
    minn[i]=a[q[l]];//minn[i]表示以 i 结尾的长度为 len 的序列中的最小值
}

typedef double db;
const db pi = acos(-1.0);
const db inf = 1e100;
const db eps = 1e-8;
int sign(db a) { return a < -eps ? -1 : a > eps; }
int db_cmp(db a, db b){ return sign(a-b); }
int inmid(db k1,db k2,db k3){return sign(k1-k3)*sign(k2-k3)<=0;}// k3 在 [k1,k2] 内

struct Point{
    db x,y;
    Point(){}
    Point(db _x,db _y) : x(_x),y(_y){}
    Point operator + (const Point &k1) const{return Point(k1.x+x,k1.y+y);}
    Point operator - (const Point &k1) const{return Point(x-k1.x,y-k1.y);}
    Point operator * (const db k1) const{return Point(x*k1,y*k1);}
    Point operator / (const db k1) const{return Point(x/k1,y/k1);}
    db operator * (const Point b) const{return x * b.x + y * b.y;}//点积
    db operator ^ (const Point b) const{return x * b.y - y * b.x;}//叉积,顺时针为负
    bool operator == (const Point &k1) const{return db_cmp(x,k1.x)==0&&db_cmp(y,k1.y)==0;}
    Point rotate(db k1){return Point(x*cos(k1)-y*sin(k1),x*sin(k1)+y*cos(k1));}// 逆时针旋转 
    Point rotate90(){return Point(-y,x);}
    db abs(){return sqrt(x*x+y*y);}
    db abs2(){return x*x+y*y;}
    Point unit(){return *this/abs();}
    db angle(){return atan2(y,x);}
    bool operator < (const Point k1) const{//极角排序
        int p1=sign(y)==1||(sign(y)==0&&sign(x)==-1),p2=sign(k1.y)==1||(sign(k1.y)==0&&sign(k1.x)==-1);
        return p1<p2||(p1==p2&&sign(*this^k1)>0);
    }
    void out(){printf("%.10f %.10f\n",x,y);}
};
typedef Point Vector;
int inmid(Point k1,Point k2,Point k3){return inmid(k1.x,k2.x,k3.x)&&inmid(k1.y,k2.y,k3.y);}
db angleOfTwoVector(Vector a, Vector b) {return atan2(a ^ b, a * b);}
Point proj(Point q,Point k1,Point k2){ // q 到直线 k1,k2 的投影 
    Point k=k2-k1;
    return k1+k*((q-k1)*k/k.abs2());
}
Point reflect(Point q,Point k1,Point k2){// q 关于直线 k1,k2 的对称点
    return proj(q,k1,k2)*2-q;
}
Point getLL(Point k1,Point k2,Point k3,Point k4){//直线交点
    db w1=(k1-k3)^(k4-k3),w2=(k4-k3)^(k2-k3);
    return (k1*w2+k2*w1)/(w1+w2);
}
int intersect(db l1,db r1,db l2,db r2){//是否有交集
    if (l1>r1) swap(l1,r1); if (l2>r2) swap(l2,r2); return db_cmp(r1,l2)!=-1&&db_cmp(r2,l1)!=-1;
}
int checkSL(Point k1,Point k2,Point k3,Point k4){// 求线段 (S) k1,k2 和直线 (L) k3,k4 的交点 
    return sign((k3-k1)^(k4-k1))*sign((k3-k2)^(k4-k2))<=0;
}
int checkSS(Point k1,Point k2,Point k3,Point k4){//两线段是否相交
    return intersect(k1.x,k2.x,k3.x,k4.x)&&intersect(k1.y,k2.y,k3.y,k4.y)&&checkSL(k1,k2,k3,k4)&&checkSL(k3,k4,k1,k2);
}
db disPP(Point k1,Point k2){return (k2-k1).abs();}
db disPP2(Point k1,Point k2){return (k2-k1).abs2();}
db disPS(Point q,Point k1,Point k2){
    Point k3=proj(q,k1,k2);
    if (inmid(k1,k2,k3)) return disPP(q,k3); 
    return min(disPP(q,k1),disPP(q,k2));
}
db disPL(Point q,Point k1,Point k2){
    if(k1==k2)return disPP(q,k1);
    return fabs((q - k1) ^ (k2 - k1)) / (k2-k1).abs();
}
db disSS(Point k1,Point k2,Point k3,Point k4){
    if (checkSS(k1,k2,k3,k4)) return 0;
    return min(min(disPS(k1,k3,k4),disPS(k2,k3,k4)),min(disPS(k3,k1,k2),disPS(k4,k1,k2)));
}
db disSL(Point k1,Point k2,Point k3,Point k4){
    if (checkSL(k1,k2,k3,k4)) return 0;
    return min(disPL(k1,k3,k4),disPL(k2,k3,k4));
}
int onS(Point q,Point k1,Point k2){return inmid(k1,k2,q)&&sign((k1-q)^(k2-k1))==0;}

struct PolarPoint {
    db Angle, Length;
    PolarPoint(db a,db b):Angle(a),Length(b){}
};
Vector PolarPointToVector(PolarPoint a) {
    return (Vector){a.Length * cos(a.Angle),a.Length * sin(a.Angle)};
}
PolarPoint VectorToPolarPoint (Vector a){
	return PolarPoint(a.angle(),a.abs());
}