#include <stdio.h>

#include <iostream>

#include <string.h>

#include <algorithm>

#include <math.h>

using namespace std;

const int N = ;

int n,m;

int father[N];

int _find(int x){

    if(x==father[x]) return x;

    return _find(father[x]);

}

int main(){

    while(scanf("%d",&n)!=EOF,n){

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

            father[i] = i;

        }

        scanf("%d",&m);

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

            int a,b;

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

            int x = _find(a);

            int y = _find(b);

            father[x] = y;

        }

        int ans = ;

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

            if(father[i]==i) ans++;

        }

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

    }

}

#include <stdio.h>

#include <iostream>

#include <string.h>

#include <algorithm>

#include <math.h>

using namespace std;

const int N = ;

int n,m;

int father[N];

struct Edge{

    int s,e,len;

}edge[N*(N-)/];

int _find(int x){

    if(x==father[x]) return x;

    return _find(father[x]);

}

int cmp(Edge a,Edge b){

    return a.len<b.len;

}

int kruskal(int m){

    sort(edge+,edge+m+,cmp);

    int cost = ;

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

        int x = _find(edge[i].s);

        int y  = _find(edge[i].e);

        if(x!=y){

            father[x] = y;

            cost+=edge[i].len;

        }

    }

    return cost;

}

int main(){

    while(scanf("%d",&n)!=EOF,n){

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

            father[i] = i;

        }

        int m = n*(n-)/;

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

            scanf("%d%d%d",&edge[i].s,&edge[i].e,&edge[i].len);

        }

        printf("%d\n",kruskal(m));

    }

}

#include <stdio.h>

#include <iostream>

#include <string.h>

#include <algorithm>

#include <math.h>

using namespace std;

const int M = ;

const int N = M*(M-)/;

struct Edge{

    int s,e,len;

}edge[N];

int father[M],n,m;

int _find(int x){

    if(x==father[x]) return x;

    return _find(father[x]);

}

int cmp(Edge a,Edge b){

    return a.len<b.len;

}

int kruskal(int m){

    sort(edge+,edge+m+,cmp);

    int cost = ;

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

        int x = _find(edge[i].s);

        int y = _find(edge[i].e);

        if(x!=y){

            father[x] = y;

            cost += edge[i].len;

        }

    }

    return cost;

}

int main(){

    while(scanf("%d%d",&n,&m)!=EOF,n){

        for(int i=;i<=m;i++) father[i] = i;

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

            scanf("%d%d%d",&edge[i].s,&edge[i].e,&edge[i].len);

        }

        int cost = kruskal(n);

        int ans = ;

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

            if(father[i]==i) ans++;

        }

        if(ans==) printf("%d\n",cost);

        else printf("?\n");

    }

}

#include <stdio.h>

#include <iostream>

#include <string.h>

#include <algorithm>

#include <math.h>

using namespace std;

const int N = ;

const double eps = 1e-;

struct Point{

    int x,y;

}p[N];

struct Edge{

    int s,e;

    double len;

}edge[N*(N-)/];

int father[N];

int n;

int _find(int x){

    if(x==father[x]) return x;

    return _find(father[x]);

}

double dis(Point a,Point b){

    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

}

bool check(double k){

    if(k+eps<) return false;

    if(k-eps>) return false;

    return true;

}

int cmp(Edge a,Edge b){

    return a.len<b.len;

}

double kruskal(int m){

    sort(edge+,edge+m+,cmp);

    double cost = ;

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

        int x = _find(edge[i].s);

        int y = _find(edge[i].e);

        if(x!=y){

            father[x] = y;

            cost +=edge[i].len;;

        }

    }

    return cost;

}

int main(){

    int T;

    scanf("%d",&T);

    while(T--){

        scanf("%d",&n);

        for(int i=;i<n;i++) father[i] = i;

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

            scanf("%d%d",&p[i].x,&p[i].y);

        }

        int m =;

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

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

                double len = dis(p[i],p[j]);

                if(!check(len)) continue;

                edge[m].s = i;

                edge[m].e = j;

                edge[m++].len = dis(p[i],p[j]);

            }

        }

        m--;

        double cost = kruskal(m);

        int ans = ;

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

            if(father[i]==i) ans++;

        }

        if(ans==) printf("%.1lf\n",cost*);

        else printf("oh!\n");

    }

}

#include <stdio.h>

#include <iostream>

#include <string.h>

#include <algorithm>

#include <math.h>

using namespace std;

const int N = ;

struct Edge{

    int s,e,len;

}edge[N*(N-)/];

int n,m;

int father[N];

int _find(int x){

    if(x==father[x]) return x;

    return _find(father[x]);

}

int cmp(Edge a,Edge b){

    return a.len<b.len;

}

int kruskal(int m){

    sort(edge+,edge+m+,cmp);

    int cost = ;

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

        int x = _find(edge[i].s);

        int y = _find(edge[i].e);

        if(x!=y){

            father[x] = y;

            cost+=edge[i].len;

        }

    }

    return cost;

}

int main(){

    while(scanf("%d",&n)!=EOF,n){

        for(int i=;i<=n;i++) father[i] = i;

        int m = n*(n-)/;

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

            int c,d;

            scanf("%d%d%d%d",&edge[i].s,&edge[i].e,&c,&d);

            if(!d) edge[i].len=c;

            else edge[i].len =;

        }

        printf("%d\n",kruskal(m));

    }

}