#include <iostream>

#include <stdio.h>

#include <math.h>

#include <string.h>

#include <queue>

#include <stack>

#include <algorithm>

#include <map>

#include <string>

typedef long long LL;

#define INF 0x3f3f3f3f

#define met(a, b) memset(a, b, sizeof(a))

#define N 200005

using namespace std;

struct node

{

    int v, w, Next;

}G[N], e[N];

int n, m, dist[N], vis[N], A, B;

int l[N];

int Head[N], cnt;

void Add(int u, int v, int w)

{

    G[cnt].v = v;

    G[cnt].w = w;

    G[cnt].Next = Head[u];

    Head[u] = cnt++;

}

int Head1[N], cnt1;

void Add1(int u, int v, int w)

{

    e[cnt1].v = v;

    e[cnt1].w = w;

    e[cnt1].Next = Head1[u];

    Head1[u] = cnt1++;

}

void spfa()

{

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

        dist[i] = INF;

    met(vis, );

    queue<int>Q;

    Q.push(A);

    vis[A] = ;

    dist[A] = ;

    while(!Q.empty())

    {

        int p = Q.front();Q.pop();

        vis[p] = ;

        for(int i=Head[p]; i!=-; i=G[i].Next)

        {

            int q = G[i].v;

            if(dist[q] > dist[p]+G[i].w)

            {

                dist[q] = dist[p]+G[i].w;

                if(!vis[q])

                {

                    vis[q] = ;

                    Q.push(q);

                }

            }

        }

    }

}

bool bfs(int s, int End)

{

    met(l, );

    queue<int>Q;

    Q.push(s);

    l[s] = ;

    while(!Q.empty())

    {

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

        if(u == End)return true;

        for(int i=Head1[u]; i!=-; i=e[i].Next)

        {

            int v = e[i].v;

            if(!l[v] && e[i].w)

            {

                l[v] = l[u]+;

                Q.push(v);

            }

        }

    }

    return false;

}

int dfs(int u, int MaxFlow, int End)

{

    if(u == End)return MaxFlow;

    int uflow = ;

    for(int j=Head1[u]; j!=-; j=e[j].Next)

    {

        int v = e[j].v;

        if(l[v]==l[u]+ && e[j].w)

        {

            int flow = min(e[j].w, MaxFlow-uflow);

            flow = dfs(v, flow, End);

            e[j].w -= flow;

            e[j^].w += flow;

            uflow += flow;

            if(uflow == MaxFlow)

                break;

        }

    }

    if(uflow == )

        l[u] = ;

    return uflow;

}

int Dinic()

{

    int MaxFlow = ;

    while(bfs(A, B))

        MaxFlow += dfs(A, INF, B);

    return MaxFlow;

}

int main()

{

    int T;

    scanf("%d", &T);

    while(T--)

    {

        met(Head, -);

        cnt = ;

        met(Head1, -);

        cnt1 = ;

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

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

        {

            int u, v, w;

            scanf("%d %d %d", &u, &v, &w);

            if(u == v)continue;

            Add(u, v, w);

        }

        scanf("%d %d", &A, &B);

        spfa();///更新dist；

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

        {

            for(int j=Head[i]; j!=-; j=G[j].Next)

            {

                int v = G[j].v;

                if(dist[v] == dist[i]+G[j].w)///建立新的网络流图；

                {

                    Add1(i, v, );

                    Add1(v, i, );

                }

            }

        }

        int ans = Dinic();///求最大流即可；

        printf("%d\n", ans);

    }

    return ;

}