/*
表示很久以前就看到了这道题
一直不敢做啊(Orz原因是因为题目太长看不懂)
关键是vijos上的那个∑公式看不清 所以给了我逃避的理由2333
现在终于下定决心好好做一下
其实发现也不难的(虽然自己一开始没想到这种做法(害羞~))
这题好像有点类似拓扑排序的样子
涉及到了入度和出度酱紫~
我们从输入点开始传递C值，如果C为正则可以传递。
注意到只有当一个结点的所有入度全部传递完成之后这个结点才可以进行传递，而且结点传递之前需要检查C的正负。
用in[],out[]分别记录入度和出度，用一个队列维护入度已经求完的结点，边我们可以用邻接向量存
考虑它所有出度的终点，考虑完成后出队，对于考虑结点而言，对所有出度的in减1，同时判断是否可以入队。
这样其实就很简单了，输出最后网络输出层的时候，我们可以明确当且仅当out[i]=0时(即出度为0)
i点才是最后网络输出层其中的一个点
然后我们就判断所有的最后网络输出层的点有无正值
如果有的话说明有兴奋状态，就输出
如果一个都没有就输出NULL
题目还是很简单的没有什么难点，主要是要看懂题目意思
唉说到底还是考语文啊(友尽><)
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;

const int Maxn=205;
struct Edge
{
    int from,to,w;
    Edge(int from,int to,int w):from(from),to(to),w(w){} 
};
vector<Edge> edges;
vector<int> g[Maxn];
queue<int> q;
int in[Maxn],out[Maxn];
int c[Maxn],u[Maxn];
int n,m;

void addEdge(int from,int to,int w)
{
    edges.push_back(Edge(from,to,w));
    int d=edges.size();
    g[from].push_back(d-1);
    in[to]++,out[from]++;
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>c[i]>>u[i];
        if(c[i]>0)
            q.push(i);
        if(c[i]==0)
            c[i]-=u[i];
    }
    int x,y,v;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>v;
        addEdge(x,y,v);
    }

    while(!q.empty())
    {
        int k=q.front();    q.pop();
        if(c[k]>0)
        {
            for(int i=0;i<g[k].size();i++)
            {
                int v=edges[g[k][i]].to;
                int w=edges[g[k][i]].w;
                c[v]+=w*c[k];
                if(!(--in[v]))
                    q.push(v);
            }
        }
    }
    bool f=1;
    for(int i=1;i<=n;i++)
        if(!out[i]&&c[i]>0)
        {
            cout<<i<<" "<<c[i]<<endl;
            f=0;
        }
    if(f)
        cout<<"NULL"<<endl;
    return 0;
}
     

#include<cstdio>
#include<queue>
#include<cstring> 
using namespace std;
const int N=201;
queue<int>top;
int u[N],c[N],w[N][N],vis[N],in[N],out[N];
int n,p,i,j,x,y,z,f;
void read()
{
    memset(w,1,sizeof(w));
    scanf("%d%d",&n,&p);
    for(i=1;i<=n;i++)
        scanf("%d%d",&c[i],&u[i]);
    for(i=1;i<=p;i++)
        scanf("%d%d%d",&x,&y,&z),
        w[x][y]=z,
        in[y]++,out[x]++;
    for(i=1;i<=n;i++)
        if(in[i])
            c[i]-=u[i];
        else if(c[i]>0)
            top.push(i);
}
void work()
{
    while(!top.empty())
    {
        int i=top.front(),j,flag=0;top.pop();
        for(j=1;j<=n;j++)
            if(w[i][j]!=16843009)
            {
                flag=1;
                c[j]+=w[i][j]*c[i];
                in[j]--;
                if(!in[j]&&c[j]>0) top.push(j);
            }
    }
    for(i=1;i<=n;i++)
        if(!out[i]&&c[i]>0)
            printf("%d %d\n",i,c[i]),f++;
    if(!f) printf("NULL");
}
int main()
{
    read();work();
return 0;
}

#include<cstdio>
const int N=201;
struct tree
{
    int num,son[N];
}t[N];
int u[N],c[N],w[N][N],in[N],out[N];
int n,p,i,j,x,y,z,f;
int main()
{
    scanf("%d%d",&n,&p);
    for(i=1;i<=n;i++)
        scanf("%d%d",&c[i],&u[i]);
    for(i=1;i<=p;i++)
        scanf("%d%d%d",&x,&y,&z),
        w[x][y]=z,
        out[x]++,in[y]++,
        t[x].son[++t[x].num]=y;
    for(i=1;i<=n;i++)
        if(!in[i]&&out[i]&&c[i]>0)
                for(j=1;j<=t[i].num;j++)
                in[t[i].son[j]]--,
                c[t[i].son[j]]+=w[i][t[i].son[j]]*c[i],
                c[t[i].son[j]]-=in[t[i].son[j]]==0?u[t[i].son[j]]:0;
    for(i=1;i<=n;i++)
        if(!out[i]&&c[i]>0)
            printf("%d %d\n",i,c[i]),
            f=1;
    if(!f)
        printf("NULL");
return 0;
}

#include<iostream>
#include<cstdio>
#include<vector>
#include<set>
#define mp(a,b) make_pair(a,b)

using namespace std;
const int maxn = 210;
vector<pair<int,int> > e[maxn];
vector<int> Q;
int c[maxn];
int n,m;
int u[maxn];
bool inv[maxn];
bool t[maxn];
int ins[maxn];
inline void input() {
    scanf("%d%d",&n,&m);
    for(int i = 1; i <= n; i++) {
        scanf("%d",&c[i]);
        if(c[i] != 0) Q.push_back(i);
        scanf("%d",&u[i]);
    }
    for(int i = 1; i <= m; i++) {
        int x,y,val;
        scanf("%d%d%d",&x,&y,&val);
        t[x] = true;
        e[x].push_back(mp(y,val));
        ins[y]++;
    }
    return ;
}
void dfs(int now) {
    for(auto x:e[now]) {
        int t1 = now,t2 = x.first;
        c[t2] += (x.second * c[t1]);
        ins[t2]--;
        if(!ins[t2]) {
            c[t2] -= u[t2];
            if(c[t2] > 0) dfs(t2);
        }
    }
    return;
}
inline void work() {
    for(auto x:Q) dfs(x);
    return;
}
inline void print() {
    bool flag = true;
    for(int i = 1; i <= n; i++) {
        if(t[i] == 0 && c[i] > 0) printf("%d %d\n",i,c[i]),flag = false;
    }
    if(flag) puts("NULL");
    return;
}
int main() {
    input();
    work();
    print();
    return 0;//直接复制粘贴会爆蛋，建议理解了代码之后自己打一遍。
}

#include <stdio.h>
#include <vector>
#include <queue>
using namespace std;
const int maxn=505;

int w[maxn][maxn];
int c[maxn],cut[maxn];
vector<int>vec[maxn];
int in[maxn],out[maxn];
priority_queue<int,vector<int>,greater<int> >q;
int n,p;
int ans[maxn],num[maxn],cnt;

void bfs()
{
    for(int i=1;i<=n;i++)
        if(in[i]==0) q.push(i);
    while(!q.empty())
    {
        int u=q.top();q.pop();
        if(out[u]==0)
        {
            ans[++cnt]=c[u];
            num[cnt]=u;
            continue;
        }
        int d=vec[u].size();
        for(int i=0;i<d;i++)
        {
            int v=vec[u][i];
            if(c[u]>=1) c[v]+=c[u]*w[u][v];
            out[u]--;
            in[v]--;
            if(in[v]==0) c[v]-=cut[v],q.push(v);
        }
    }
}

int main()
{
    scanf("%d%d",&n,&p);
    for(int i=1;i<=n;i++) scanf("%d%d",&c[i],&cut[i]);
    for(int i=1;i<=p;i++)
    {
        int u,v,val;
        scanf("%d%d%d",&u,&v,&val);
        w[u][v]=val;
        vec[u].push_back(v);
        out[u]++,in[v]++;
    }
    bfs();
    bool flag=false;
    for(int i=1;i<=cnt;i++)
        if(ans[i]>=1)
        {
            flag=true;
            break;
        }
    if(flag)
    {
        for(int i=1;i<=cnt;i++)
            if(ans[i]>=1)
                printf("%d %d\n",num[i],ans[i]);        
    }
    else printf("NULL");
    return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct zhu{
    int v,w,next;
}e[40010];
struct point{
    int num;
    int c;
    int u;
    bool operator < (point &xx)const{
        return xx.num<num;
    }
    point(){}
    point(int num,int c,int u):num(num),c(c),u(u){}
}r[210];
int head[210],inq[210],size=0;
priority_queue <int,vector<int>,greater<int> > q;
int ok=0;
inline void add(int u,int v,int w){
    e[size].v=v;
    e[size].w=w;
    e[size].next=head[u];
    head[u]=size++;
} 
int main(){
    memset(head,-1,sizeof(head));
    int n,p;
    scanf("%d%d",&n,&p);
    for(int i=1;i<=n;++i){
        int c,u;
        scanf("%d%d",&c,&u);
        r[i]=point(i,c,u);
        if(c>0){
            r[i].c+=u;
            q.push(i);
        }
    }
    for(int i=1;i<=p;++i){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    }
    while(!q.empty()){
        int u=q.top();
        q.pop();
        r[u].c-=r[u].u;
        if(r[u].c<=0)continue;
        if(head[u]==-1){
            ok=1;
            printf("%d %d\n",u,r[u].c);
        }
        for(int i=head[u];i!=-1;i=e[i].next){
            int v=e[i].v;
            r[v].c+=e[i].w*r[u].c;
            if(!inq[v]){
                inq[v]=1;
                q.push(v);
            }
        }
    }
    if(!ok)printf("NULL");
    return 0;
}

#include <cstdio>
#include <algorithm>
#include <queue>

using namespace std;

const int maxN = 200 + 5;

int W[maxN][maxN]; //有向边的权值
bool linked[maxN][maxN]; //linked[u][v] = u->v是否有一条有向边相连
int U[maxN], C[maxN];
int inDeg[maxN], outDeg[maxN]; //分别记录每个点的入度和出度
int N, P;

void input()
{
    scanf("%d%d", &N, &P);
    for (int i = 1; i <= N; i++)
        scanf("%d%d", C + i, U + i);
    for (int u, v, w, i = 1; i <= P; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        outDeg[u] += 1;
        inDeg[v] += 1;
        W[u][v] = w;
        linked[u][v] = true;
    }
}

void bfs()
{
    queue<int> que;
    for (int i = 1; i <= N; i++)
        if (inDeg[i] == 0) //先将所有入度为0的点（也就是输入层）加入队列
        {
            que.push(i);
            C[i] += U[i]; //这里与while循环内的C[cur] -= U[cur]对应
            //输入层的C[i]先加后减所以不变，其他层的C[i]会减去它的阈值
        }

    while (!que.empty()) //BFS过程可以保证每个节点都入队一次
    {
        int cur = que.front();
        que.pop();

        C[cur] -= U[cur]; //减去当前点的阈值
        for (int to = 1; to <= N; to++)
        {
            if (!linked[cur][to])
                continue;
            if (C[cur] > 0)
                C[to] += (W[cur][to] * C[cur]);
            if (--inDeg[to] == 0) //通过删边来判断下一个节点是否已接收来自上一层的全部信息
                que.push(to);
        }
    }
}

int main()
{
    input();
    bfs();
    bool outputted = false; //标记是否已经输出某个节点
    for (int i = 1; i <= N; i++)
        if (outDeg[i] == 0 && C[i] > 0) //这里Vijos题面描述有误，仅当C[i] > 0时才输出
            //outDeg[i] == 0表示该节点属于输出层（这里包含了节点既是输入层也是输出层的情况）
        {
            printf("%d %d\n", i, C[i]);
            outputted = true;
        }
    if (!outputted)
        printf("NULL");
    return 0;
}

type    int=longint;
var
        i,n,p,tail,head:int;
        c,u,a,b,d:array[0..201]of int;
        flag:boolean;
        f,s:array[0..201]of boolean;
        w:array[0..201,0..201]of int;
procedure hunter;
var
        i:int;
begin
        readln(n,p);
        for i:=1 to n do read(c[i],u[i]);
        for i:=1 to n do
        begin
                f[i]:=true;
                s[i]:=true;
        end;
        fillchar(w,sizeof(w),0);
        for i:=1 to p do read(a[i],b[i],w[a[i],b[i]]);
        for i:=1 to p do f[a[i]]:=false;
        tail:=0;
        for i:=1 to n do if c[i]>0 then
        begin
                inc(tail);
                d[tail]:=i;
                s[i]:=false;
                c[i]:=c[i]+u[i];
        end;
        head:=1;
        flag:=true;
end;

begin
        hunter;
        repeat
                c[d[head]]:=c[d[head]]-u[d[head]];
                if c[d[head]]>0 then
                begin
                for i:=1 to n do if w[d[head],i]<>0 then
                begin
                        c[i]:=c[i]+w[d[head],i]*c[d[head]];
                        if s[i] then
                        begin
                                inc(tail);
                                d[tail]:=i;
                                s[i]:=false;
                        end;
                end;
                end;
                inc(head);
        until   head>tail;
        for i:=1 to n do if f[i] and(c[i]>0) then
        begin
                writeln(i,' ',c[i]);
                flag:=false;
        end;
        if flag then writeln('NULL');       
end.