//Accepted    1812 KB    514 ms
/*
    source:hdu4067
    time  :20150816
    by    :songt
  */
/*题解：网络流
首先我们贪心建图：对于u到v的一条边，保留的费用为a，删除的费用为b
用sum记录我们的花费;
即对于(u,v,a,b),如果
    1.a<=b 那么说明保留的花费更小，我们选择保留这条边，那么in[v]++,out[u]++ (in,out表示点的入度和出度),sum+=a
    但是如果我们需要删除这条边的话，那么我们需要需要选择边(v,u,b-a);所以建边(v,u,1,b-a)
    2.a>b 那么说明删除的花费更小，我们选择删除这条边，那么sum+=b
    但是如果我们需要保留这条边的话，那么我们需要选择边(u,v,a-b),所以建边（u,v,1,a-b)

    这样对于每一个顶点，如果选择了一条和他相连的出边，那么这个顶点的出度就会加1，如果选择了一条和他相连的入边，
    那么和这个顶点相连的入度就会加1，所以下面我们只需要通过选边来平衡每个节点的入度和出度就好了。

    由于s,和t的要求，我们可以先把s的入度+1，t的出度+1，这样他们和其他点一样平衡就好了

    增加超级源点src和汇点des
    对于每个点i有：
    1.in[i]>out[i],说明点i的入度更大，需要选择出去的边，所以我们从src向i建边，容量为需要平衡的in[i]-out[i]
    2.in[i]<=out[i],说明点i的出度更大，需要选择入边，所以我们从i向des建边，容量为需要平衡的out[i]-in[i]

    这样，就可以通过一遍费用流来需找最小需要平衡的费用cost，ans=sum+cost
    如果图的网络流不能平衡所有的节点的话，那么无解。(flow!=sum(src),最大流不等于从src出边的流量和)

  */
#include <cstdio>
#include <cstring>
#include<algorithm>
#include<queue>
#include<vector>

#define INF 1e9
using namespace std;
*;

struct Edge
{
    int from,to,cap,flow,cost;
    Edge(){}
    Edge(int f,int t,int c,int fl,int co):from(f),to(t),cap(c),flow(fl),cost(co){}
};

struct MCMF
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool inq[maxn];
    int d[maxn];
    int p[maxn];
    int a[maxn];

    void init(int n,int s,int t)
    {
        this->n=n, this->s=s, this->t=t;
        edges.clear();
        ;i<n;++i) G[i].clear();
    }

    void AddEdge(int from,int to,int cap,int cost)
    {
        edges.push_back(Edge(,cost));
        edges.push_back(Edge(to,,,-cost));
        m=edges.size();
        G[);
        G[to].push_back(m-);
    }

    bool BellmanFord(int &flow,int &cost)
    {
        queue<int> Q;
        ;i<n;++i) d[i]=INF;
        memset(inq,,sizeof(inq));
        Q.push(s),inq[s]=,a[s]=INF,p[s]=;

        while(!Q.empty())
        {
            int u=Q.front(); Q.pop();
            inq[u]=false;
            ;i<G[u].size();++i)
            {
                Edge &e=edges[G[u][i]];
                if(e.cap>e.flow && d[e.to]>d[u]+e.cost)
                {
                    d[e.to]=d[u]+e.cost;
                    a[e.to]=min(a[u],e.cap-e.flow);
                    p[e.to]=G[u][i];
                    if(!inq[e.to]){inq[e.to]=true; Q.push(e.to);}
                }
            }
        }
        if(d[t]==INF) return false;
        flow += a[t];
        cost += a[t]*d[t];
        int u=t;
        while(u!=s)
        {
            edges[p[u]].flow +=a[t];
            edges[p[u]^].flow -=a[t];
            u=edges[p[u]].from;
        }
        return true;
    }

    int solve(int &cost)
    {
        ;
        cost=;
        while(BellmanFord(flow,cost));
        return flow;
    }
}MM;

int in[maxn],out[maxn];

void Deal()
{
    int n,m,s,t;
    int u,v,a,b;
    ;
    memset(,sizeof(in));
    memset(,sizeof(out));
    scanf("%d%d%d%d",&n,&m,&s,&t);
    ;
    ;
    MM.init(des+,src,des);
    ;i<m;i++)
    {
        scanf("%d%d%d%d",&u,&v,&a,&b);
        if (a<=b)
        {
            MM.AddEdge(v,u,,b-a);
            in[v]++;
            out[u]++;
            sum+=a;
        }
        else
        {
            sum+=b;
            MM.AddEdge(u,v,,a-b);
        }
    }
    in[s]++,out[t]++;
    ;
    ;i<=n;i++)
    {
        ),tmp+=in[i]-out[i];
        );
    }
    int cost;
    int ans=MM.solve(cost);
    if (ans!=tmp)
    {
        printf("impossible\n");
    }
    else
    {
        printf("%d\n",sum+cost);
    }
}

int main()
{
    int T;
    ;
    scanf("%d",&T);
    while (T--)
    {
        printf("Case %d: ",++t);
        Deal();
    }
    ;
}