#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

const int MAXN=150;
const int INF=1<<20;

struct Machine{
    int flow;
    int in[15],out[15];
}mac[MAXN];

//检查该机器和源点之间是否有边
bool checkS(Machine a,int P){
    for(int i=0;i<P;i++)
        if(a.in[i]==1)
            return false;
    return true;
}

//检查该机器和汇点n+1之间是否有边
bool checkT(Machine a,int P){
    for(int i=0;i<P;i++)
        if(a.out[i]!=1)
            return false;
    return true;
}

//检查两个机器之间是否有边
bool checkEdge(Machine a,Machine b,int P){
    for(int i=0;i<P;i++)
        if(a.out[i]+b.in[i]==1)
            return false;
    return true;
}

struct Edge{
    int to,next;
    int init;
    int flow;
}edges[MAXN*10];


int head[MAXN];
int tot;
void init(){
    tot=0;
    memset(head,-1,sizeof(head));
}

void addEdge(int u,int v,int flow){
    edges[tot].to=v;
    edges[tot].flow=flow;
    edges[tot].init=flow;
    edges[tot].next=head[u];
    head[u]=tot++;
}

int level[MAXN];
bool makelevel(int s,int t ){
    memset(level,0,sizeof(level));
    level[s]=1;
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int u=q.front();q.pop();
        if(u==t) return true;
        for(int i=head[u];i!=-1;i=edges[i].next){
            int v=edges[i].to;
            if(!level[v]&&edges[i].flow){
                level[v]=level[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}

int DFS(int now,int maxf,int t){
    if(now==t) return maxf;
    int ret=0,f;
    for(int k=head[now];k!=-1;k=edges[k].next){
        int v=edges[k].to;
        if(edges[k].flow&&level[v]==level[now]+1){
            f=DFS(v,min(maxf-ret,edges[k].flow),t);
            edges[k].flow-=f;
            edges[k^1].flow+=f;
            ret+=f;
        }
        if(ret==maxf) return ret;
    }
    return ret;
}

int Dinic(int s,int t){
    int ans=0;
    while(makelevel(s,t))
        ans+=DFS(s,INF,t);
    return ans;
}

struct Node{
    int u;
    int v;
    int cap;
    Node(int u,int v,int cap):u(u),v(v),cap(cap){};
    Node(){};
};
 int main(){
    int P,N;
    while(scanf("%d%d",&P,&N)!=EOF){
    for(int i=1;i<=N;i++){
        scanf("%d",&mac[i].flow);
        for(int j=0;j<P;j++)
            scanf("%d",&mac[i].in[j]);
        for(int j=0;j<P;j++)
            scanf("%d",&mac[i].out[j]);
    }
    //下面是建图
    init();
    for(int i=1;i<=N;i++){
        if(checkS(mac[i],P)){    //这是检查该机器和源点0是否有边
            addEdge(0,i,mac[i].flow);
            addEdge(i,0,0);
        }
        if(checkT(mac[i],P)){  //这是检查该机器和汇点N+1是否有边
            addEdge(i,N+1,mac[i].flow);
            addEdge(N+1,i,0);
        }
        for(int j=1;j<=N;j++){   //这是检查机器i和机器j是否右边
            if(i==j) continue;
            if(checkEdge(mac[i],mac[j],P)){
                addEdge(i,j,mac[i].flow);
                addEdge(j,i,0);
            }
        }
    }

    int res=Dinic(0,N+1);
    vector<Node>ans;
    ans.clear();
    //如果最后残留网络的容量小于初始容量，说明该边是最大流走过的边
    for(int u=1;u<=N;u++){
        for(int j=head[u];j!=-1;j=edges[j].next){
            int v=edges[j].to;
            if(v>0&&v<=N&&edges[j].flow<edges[j].init){
                ans.push_back(Node(u,v,edges[j].init-edges[j].flow));
            }
        }
    }

    printf("%d %d\n",res,ans.size());
    for(int i=0;i<ans.size();i++){
        printf("%d %d %d\n",ans[i].u,ans[i].v,ans[i].cap);
    }
    }
    return 0;
}