#include<bits/stdc++.h>
#define endl '\n'
using namespace std;

struct Group
{
    int x,y,num;
};

struct Region
{
    vector<int> ps;
    vector<int> qs;
    long long P,Q;
};

struct Cmd
{
    int x1,x2,y1,y2,num;
    Cmd() {}
    Cmd(int _x1,int _x2,int _y1,int _y2,int _num)
    {
        x1=_x1;
        x2=_x2;
        y1=_y1;
        y2=_y2;
        num=_num;
    }
};

const int offsetX[4]={-1,0,1,0};
const int offsetY[4]={0,1,0,-1};
const int C=1e9+1;
const int S=1e9;
const int bound[5]={100,360,1300,4690,16900};
const vector<double> sq[5]={ {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 50, 100, 500, 1000, 2000, 5000, 10000, 20000, 50000},
                             {3.6, 5, 6, 7.2, 9, 10, 12, 15, 18, 20, 25, 30, 40, 50, 60, 70, 85, 100, 150, 200, 250, 300, 400, 500, 1000, 2000, 5000, 10000, 20000, 50000},
                             {13, 15, 17, 20, 25, 30, 35, 40, 45, 50, 70, 80, 90, 100, 200, 300, 500, 1000, 2000, 5000, 10000, 20000, 50000},
                             {20, 30, 40, 46.9, 48, 50, 52, 55, 58, 60, 65, 70, 75, 80, 90, 100, 110, 150, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000},
                             {50, 80, 100, 150, 169, 172, 175, 180, 184, 188, 190, 195, 200, 220, 250, 260, 300, 500, 1000, 2000, 5000, 10000, 20000, 50000} };

int n,m;
Group p[50005], q[50005];
map<long long,bool> forts;

long double curr=0,best=1e21; ///
vector<Cmd> sol, curr_sol;
Region r[300][300];

void init(int T)
{
    for(int i=0;i<T;i++)
    {
        for(int j=0;j<T;j++)
        {
            r[i][j].P=r[i][j].Q=0;
            r[i][j].ps.clear();
            r[i][j].qs.clear();
        }
    }
    return;
}

pair<int,int> go_near(int ind)
{
    int x,y;
    for(int i=0;i<4;i++)
    {
        x=q[ind].x+offsetX[i], y=q[ind].y+offsetY[i];
        if(x>=0 && x<=1e9 && y>=0 && y<=1e9 && forts[(long long) x*C+y]==0) return {ind,i};
    }
    return {-1,-1};
}

void add(long long x1,long long y1,long long x2,long long y2,int num)
{
    curr_sol.push_back(Cmd(x1,x2,y1,y2,num));
    curr+=(long double)num*sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); ///
    return;
}

long long battle(long long p,long long q)
{
    return (long long) ceil(sqrt(p*p-q*q));
}

bool _try(const int side) /// const?
{
    int T=S/side+1;
    init(T); // clear regions
    for(int i=0;i<n;i++)
    {
        int x,y;
        x=p[i].x/side;
        y=p[i].y/side;
        r[x][y].ps.push_back(i);
        r[x][y].P+=p[i].num;
    }

    for(int i=0;i<m;i++)
    {
        int x,y;
        x=q[i].x/side;
        y=q[i].y/side;
        r[x][y].qs.push_back(i);
        r[x][y].Q+=q[i].num*q[i].num;
    }

    for(int i=0;i<T;i++)
    {
        for(int j=0;j<T;j++)
        {
            if(r[i][j].Q==0) continue;
            if(r[i][j].P*r[i][j].P<r[i][j].Q) return 0;
        }
    }

    curr_sol.clear();

    for(int i=0;i<T;i++)
    {
        for(int j=0;j<T;j++)
        {
            if(r[i][j].Q==0) continue;
            pair<int,int> aim;
            for(int k=0;k<r[i][j].qs.size();k++)
            {
                aim=go_near(r[i][j].qs[k]);
                if(aim.first!=-1) break;
            }

            int x1=q[aim.first].x, y1=q[aim.first].y;
            x1+=offsetX[aim.second], y1+=offsetY[aim.second];
            for(int k=0;k<r[i][j].ps.size();k++)
            {
                add(p[r[i][j].ps[k]].x, p[r[i][j].ps[k]].y, x1, y1, p[r[i][j].ps[k]].num);
            }

            int x2=q[aim.first].x, y2=q[aim.first].y;
            add(x1,y1,x2,y2,r[i][j].P);
            r[i][j].P=battle(r[i][j].P,q[aim.first].num);
            x1=x2, y1=y2;
            for(int k=0;k<r[i][j].qs.size();k++)
            {
                if(r[i][j].qs[k]==aim.first) continue;
                x2=q[r[i][j].qs[k]].x;
                y2=q[r[i][j].qs[k]].y;
                add(x1,y1,x2,y2,r[i][j].P);
                r[i][j].P=battle(r[i][j].P,q[r[i][j].qs[k]].num);
                x1=x2, y1=y2;
            }
        }
    }

    return 1;
}

void solve(int t)
{
    for(int i=0;i<sq[t].size();i++)
    {
        curr=0;
        const int k=floor(sqrt((double)n/sq[t][i]));
        const int side=(S+k-1)/k;
        if(_try(side)==0) continue;//cout<<i<<" "<<side<<endl;
        if(curr<best)
        {
            best=curr;
            sol=curr_sol;
        }
    }
    return;
}

bool cmp(Group a, Group b)
{
    if(a.x==b.x) return a.y<b.y;
    return a.x<b.x;
}

int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);

freopen("war.in","r",stdin);
freopen("war.out","w",stdout);

int maxv=0;
cin>>n>>m;
for(int i=0;i<n;i++)
{
    cin>>p[i].x>>p[i].y>>p[i].num;
}
for(int i=0;i<m;i++)
{
    cin>>q[i].x>>q[i].y>>q[i].num;
    maxv=max(maxv,q[i].num);
    forts[(long long)q[i].x*C+q[i].y]=1;
}

sort(q,q+m,cmp);

for(int i=0;i<5;i++)
{
    if(maxv<=bound[i])
    {
        solve(i);
        break;
    }
}

//cout<<best<<endl;
cout<<sol.size()<<endl;
for(int i=0;i<sol.size();i++)
{
    cout<<sol[i].x1<<" "<<sol[i].y1<<" "<<sol[i].x2<<" "<<sol[i].y2<<" "<<sol[i].num<<endl;
}
return 0;
}
/*
2 2
1 1 2
3 1 3
2 2 3
4 2 3
*/