#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m;
    cin>>n>>m;
    int p = 0;
    int na[n];
    int nb[n];
    int ma[m];
    int mb[m];
    int t[n][m];
    for(int i = 0;i<n;i++){
        for(int j = 0; j < m;j++){
            t[i][j]=0;
        }
    }
    int sn = 0;
    int sm = 0;
    for(int i = 0; i < n; i++){
        cin>>na[i]>>nb[i];
        sn+=na[i];
    }
    for(int i = 0; i < m; i++){
        cin>>ma[i]>>mb[i];
        sm+=ma[i];
    }
    if(sn>=sm){
        sn-=sm;
        int tk = 0;
        for(int i = 0; i < n; i=i){
            if(tk>m){
                break;
            }
            if(sn==0){ //Ceo slucaj je triv
                if(na[i]>ma[tk]){
                    na[i]-=ma[tk];
                    t[i][tk]=ma[tk];
                    p+=ma[tk];
                    mb[tk]-=ma[tk];
                    nb[i]-=ma[tk];
                    tk++;
                }
                else if(na[i]==ma[tk]){
                    t[i][tk]=ma[tk];
                    p+=ma[tk];
                    mb[tk]-=ma[tk];
                    nb[i]-=ma[tk];
                    ma[tk]=0;
                    na[i]=0;
                    tk++;
                    i++;
                }
                else{
                    ma[tk]-=na[i];
                    t[i][tk]=na[i];
                    mb[tk]-=na[i];
                    nb[i]-=na[i];
                    p+=na[i];
                    na[i]=0;
                    i++;
                }
            }
            else{
                if(ma[tk]>=na[i]){
                    t[i][tk]=na[i];
                    mb[tk]-=na[i];
                    nb[i]-=na[i];
                    ma[tk]-=na[i];
                    i++;
                }
                else{
                    if(na[i]>mb[tk] && sn>=mb[tk]-ma[tk]){ //sn dovoljno veliko
                        sn-=mb[tk]-ma[tk];                 //min u redu je dovoljno velik
                        na[i]-=mb[tk];
                        t[i][tk]=mb[tk];
                        nb[i]-=mb[tk];
                        p+=mb[tk];
                        mb[tk]=0;
                        tk++;
                    }
                    else if(na[i]==mb[tk] && sn>=mb[tk]-ma[tk]){ // iste su velicine
                        t[i][tk]=mb[tk];
                        sn-=mb[tk]-ma[tk];
                        p+=mb[tk];
                        mb[tk]=0;
                        nb[i]-=mb[tk];
                        na[i]=0;
                        tk++;
                        i++;
                    }
                    else if(sn>=na[i]-ma[tk]){ // maks u koloni je dovoljno velik
                        sn-=na[i]-ma[tk];
                        mb[tk]-=na[i];
                        t[i][tk]=na[i];
                        nb[i]-=na[i];
                        p+=na[i];
                        na[i]=0;
                        i++;
                    }                          // sn nije dovoljno velik pa ga dovodimo do nule
                    else if(na[i]>mb[tk]){    // min u redu dovoljno velik
                        na[i]-=ma[tk]+sn;
                        t[i][tk]=ma[tk]+sn;
                        mb[tk]-=ma[tk]+sn;
                        nb[i]-=ma[tk]+sn;
                        tk++;
                        sn = 0;
                    }
                    else if(na[i]==mb[tk]){    // min u redu i maks u koloni su isti
                        t[i][tk]=ma[tk]+sn;
                        nb[i]-=ma[tk]+sn;
                        mb[i]-=ma[tk]+sn;
                        na[i]-=ma[tk]+sn;      //znamo da je min u redu manji od min u vrsti pa svakako menjamo kolonu
                        tk++;
                        sn = 0;
                    }
                    else{                       //min u redu je dovoljno mali ali ga ne dovodimo do nule da bismo dobili ravnotezu
                        t[i][tk]=ma[tk]+sn;
                        mb[tk]-=ma[tk]+sn;
                        nb[i]-=ma[tk]+sn;
                        na[i]-=ma[tk]+sn;
                        tk++;
                        sn=0;
                    }
                }
            }
        }
    }
    else{
        sm-=sn;
        int i = 0;
        for(int tk = 0; tk < m; tk=tk){
            if(i>n){
                break;
            }
            if(sm==0){ //Ceo slucaj je triv
                if(ma[tk]>na[i]){
                    ma[tk]-=na[i];
                    t[i][tk]=na[i];
                    p+=na[i];
                    mb[tk]-=na[i];
                    nb[i]-=na[i];
                    i++;
                }
                else if(na[i]==ma[tk]){
                    t[i][tk]=ma[tk];
                    p+=ma[tk];
                    mb[tk]-=ma[tk];
                    nb[i]-=ma[tk];
                    ma[tk]=0;
                    na[i]=0;
                    tk++;
                    i++;
                }
                else{
                    na[i]-=ma[tk];
                    t[i][tk]=ma[tk];
                    nb[i]-=ma[tk];
                    mb[i]-=ma[tk];
                    p+=ma[tk];
                    ma[tk]=0;
                    i++;
                }
            }
            else{
                if(na[i]>=ma[tk]){
                    t[i][tk]=ma[tk];
                    nb[i]-=ma[tk];
                    mb[tk]-=ma[tk];
                    na[i]-=ma[tk];
                    tk++;
                }
                else{
                    if(ma[tk]>nb[i] && sm>=nb[i]-na[i]){ //sn dovoljno veliko
                        mb[tk]-=nb[i];
                        sm-=nb[i]-na[i];                 //min u redu je dovoljno velik
                        ma[tk]-=nb[i];
                        t[i][tk]=nb[i];
                        p+=nb[i];
                        nb[i]=0;
                        i++;
                    }
                    else if(ma[tk]==nb[i] && sm>=nb[i]-na[i]){ // iste su velicine
                        mb[tk]-=nb[i];
                        t[i][tk]=nb[i];
                        sm-=nb[i]-na[i];
                        p+=nb[i];
                        nb[i]=0;
                        ma[tk]=0;
                        tk++;
                        i++;
                    }
                    else if(sm>=ma[tk]-na[i]){ // maks u koloni je dovoljno velik
                        sm-=ma[tk]-na[i];
                        nb[i]-=ma[tk];
                        mb[tk]-=ma[tk];
                        t[i][tk]=ma[tk];
                        p+=ma[tk];
                        ma[tk]=0;
                        tk++;
                    }                          // sn nije dovoljno velik pa ga dovodimo do nule
                    else if(ma[tk]>nb[i]){    // min u redu dovoljno velik
                        ma[tk]-=na[i]+sm;
                        t[i][tk]=na[i]+sm;
                        nb[i]-=na[i]+sm;
                        mb[tk]-=na[i]+sm;
                        i++;
                        sm = 0;
                    }
                    else if(ma[tk]==nb[i]){    // min u redu i maks u koloni su isti
                        t[i][tk]=na[i]+sm;
                        nb[i]-=na[i]+sm;
                        mb[i]-=na[i]+sm;
                        ma[tk]-=na[i]+sm;      //znamo da je min u redu manji od min u vrsti pa svakako menjamo kolonu
                        i++;
                        sm = 0;
                    }
                    else{                       //min u redu je dovoljno mali ali ga ne dovodimo do nule da bismo dobili ravnotezu
                        t[i][tk]=na[i]+sm;
                        nb[i]-=na[i]+sm;
                        mb[tk]-=na[i]+sm;
                        ma[tk]-=na[i]+sm;
                        i++;
                        sm=0;
                    }
                }
            }
        }
    }
    int tr = 0;
    int tk = 0;
    while(tr<n && tk<m){
        if(nb[tr]>mb[tk]){
            t[tr][tk]+=mb[tk];
            nb[tr]-=mb[tk];
            tk++;
        }
        else if(nb[tr]==mb[tk]){
            t[tr][tk]+=mb[tk];
            tk++;
            tr++;
        }
        else{
            t[tr][tk]+=nb[tr];
            mb[tk]-=nb[tr];
            tr++;
        }
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j<m;j++){
            cout<<t[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}