#include<stdio.h>

 #include<string.h>

 #include<algorithm>

 #include<queue>

 #include<vector>

 using namespace std;

 typedef pair<int,int> pii;

 const int maxm=;

 const int INF=0x3f3f3f3f;

 struct cmp{

     bool operator()(pii a,pii b){

         return a.first>b.first;

     }

 };

 int head[],point[],val[],nxt[],size;

 bool vis[];

 int dis[],n,s,p,fa[],pa[];

 struct edge{             //弧的结构体，变量：弧的出发点、结束点、容量、流量

     int from,to,c,f;

     edge(int a,int b,int m,int n):from(a),to(b),c(m),f(n){}

 };

 struct dinic{

     int m,s,t;                    //边数、源点标号、汇点标号

     vector<edge>e;        //边

     vector<int>g[maxm];    //g[i][j]表示第i个点出发的第j条边在e中的编号

     bool vis[maxm];

     int d[maxm],cur[maxm];    //d为源点到点的距离，cur为当前遍历到的边

     void init(int n){                //初始化，n为点数量（标号0～n-1）

         for(int i=;i<n+;i++)g[i].clear();

         e.clear();

     }

     void add(int a,int b,int v){        //加入弧和反向弧

         e.push_back(edge(a,b,v,));    //正向弧容量v，反向弧容量0

         e.push_back(edge(b,a,,));

         m=e.size();

         g[a].push_back(m-);

         g[b].push_back(m-);

     }

     bool bfs(){

         memset(vis,,sizeof(vis));

         queue<int>q;

         q.push(s);

         d[s]=;

         vis[s]=;

         while(!q.empty()){

             int u=q.front();q.pop();

             for(int i=;i<g[u].size();i++){

                 edge tmp=e[g[u][i]];

                 if(!vis[tmp.to]&&tmp.c>tmp.f){

                     vis[tmp.to]=;

                     d[tmp.to]=d[u]+;

                     q.push(tmp.to);

                 }

             }

         }

         return vis[t];

     }

     int dfs(int x,int a){

         if(x==t||a==)return a;

         int flow=,f;

         for(int& i=cur[x];i<g[x].size();i++){

             edge &tmp=e[g[x][i]];

             if(d[x]+==d[tmp.to]&&(f=dfs(tmp.to,min(a,tmp.c-tmp.f)))>){

                 tmp.f+=f;

                 e[g[x][i]^].f-=f;

                 flow+=f;

                 a-=f;

                 if(a==)break;

             }

         }

         if(!flow)d[x]=-;

         return flow;

     }

     int mf(int s,int t){                //在主函数中使用的函数，求s到t的最大流

         this->s=s;

         this->t=t;

         int flow=;

         while(bfs()){

             memset(cur,,sizeof(cur));

             flow+=dfs(s,INF);

         }

         return flow;

     }

 };

 void add(int a,int b,int v){

     point[size]=b;

     val[size]=v;

     nxt[size]=head[a];

     head[a]=size++;

 }

 void dij(){

     int i;

     priority_queue<pii,vector<pii>,cmp>q;

     memset(dis,0x3f,sizeof(dis));

     memset(fa,-,sizeof(fa));

     dis[s]=;

     q.push(make_pair(dis[s],s));

     while(!q.empty()){

         pii u=q.top();

         q.pop();

         if(u.first>dis[u.second])continue;

         for(i=head[u.second];~i;i=nxt[i]){

             int j=point[i],v=u.first+val[i];

             if(!vis[i]&&dis[j]>v){

                 dis[j]=v;

                 fa[j]=u.second;

                 pa[j]=i;

                 q.push(make_pair(dis[j],j));

             }

         }

     }

 }

 int main(){

     int t;

     scanf("%d",&t);

     for(int q=;q<=t;q++){

         int m,i;

         memset(head,-,sizeof(head));

         memset(vis,,sizeof(vis));

         size=;

         scanf("%d%d",&n,&m);

         for(i=;i<=m;i++){

             int a,b,v;

             scanf("%d%d%d",&a,&b,&v);

             if(a!=b){

                 add(a,b,v);

             }

         }

         scanf("%d%d",&s,&p);

         dinic d;

         dij();

         for(i=;i<=n;++i){

             for(int j=head[i];~j;j=nxt[j]){

                 int k=point[j];

                 if(dis[i]+val[j]==dis[k])d.add(i,k,);

             }

         }

         printf("%d\n",d.mf(s,p));

     }

     return ;

 }