#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<queue>

using namespace std;

const int MAXN=;

const int MAXM=**;

const int INF=0x3f3f3f3f;

struct Edge

{

    int to,next,cap,flow;

} edge[MAXM];

int tol;

int head[MAXN];

int gap[MAXN],dep[MAXN],pre[MAXN],cur[MAXN];

void init()

{

    tol=;

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

}

void Addedge(int u,int v,int w,int rw=)

{

    edge[tol].to = v;

    edge[tol].cap = w;

    edge[tol].next = head[u];

    edge[tol].flow = ;

    head[u] = tol++;

    edge[tol].to = u;

    edge[tol].cap = rw;

    edge[tol].next = head[v];

    edge[tol].flow = ;

    head[v]=tol++;

}

int sap(int start,int end,int N)

{

    memset(gap,,sizeof(gap));

    memset(dep,,sizeof(dep));

    memcpy(cur,head,sizeof(head));

    int u=start;

    pre[u]=-;

    gap[]=N;

    int ans=;

    while(dep[start]<N)

    {

        if(u==end)

        {

            int Min=INF;

            for(int i=pre[u]; i!=-; i=pre[edge[i^].to])

                if(Min>edge[i].cap-edge[i].flow)

                    Min=edge[i].cap-edge[i].flow;

            for(int i=pre[u]; i!=-; i=pre[edge[i^].to])

            {

                edge[i].flow+=Min;

                edge[i^].flow-=Min;

            }

            u=start;

            ans+=Min;

            continue;

        }

        bool flag=false;

        int v;

        for(int i=cur[u]; i!=-; i=edge[i].next)

        {

            v=edge[i].to;

            if(edge[i].cap-edge[i].flow && dep[v]+==dep[u])

            {

                flag=true;

                cur[u]=pre[v]=i;

                break;

            }

        }

        if(flag)

        {

            u=v;

            continue;

        }

        int Min=N;

        for(int i=head[u]; i!=-; i=edge[i].next)

            if(edge[i].cap-edge[i].flow && dep[edge[i].to]<Min)

            {

                Min=dep[edge[i].to];

                cur[u]=i;

            }

        gap[dep[u]]--;

        if(!gap[dep[u]])return ans;

        dep[u]=Min+;

        gap[dep[u]]++;

        if(u!=start) u=edge[pre[u]^].to;

    }

    return ans;

}

bool vit[MAXN],sing[MAXN];

int n,m;

int dfs(int u,int p)

{

    if(vit[u])return ;

    vit[u]=;

    for(int &i=head[u]; i!=-; i=edge[i].next)

    {

        int v=edge[i].to;

        if(v!=p && edge[i].cap-edge[i].flow>)

            if(dfs(v,u)) return ;

    }

    vit[u]=;

    return ;

}

int main()

{

    int T;

    scanf("%d",&T);

    for(int t=; t<=T; t++)

    {

        init();

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

        int sum1=,sum2=;

        int x;

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

        {

            scanf("%d",&x);

            sum1+=x;

            Addedge(,i,x);

        }

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

        {

            scanf("%d",&x);

            sum2+=x;

            Addedge(i+n,n+m+,x);

        }

        if(sum1!=sum2)

        {

            printf("Case #%d: So naive!\n",t);

            continue;

        }

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

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

                Addedge(i,j+n,);

        int ans=sap(,n+m+,n+m+);

        if(ans==sum1 && ans==sum2)

        {

            int flag=;

            memset(vit,,sizeof(vit));

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

            {

                memset(vit,,sizeof(vit));

                if(dfs(i,-))

                {

                    flag=;

                    break;

                }

            }

            if(flag) printf("Case #%d: So young!\n",t);

            else printf("Case #%d: So simple!\n",t);

        }

        else printf("Case #%d: So naive!\n",t);

    }

    return ;

}