#include<stdio.h>

#include<string.h>

#include<stdlib.h>

#include<math.h>

double x[], y[], r[];

int f[][];

const double eps = 1e-;

#include<vector>

using namespace std;

vector<int> G[];

int p[], father[];

void dfs(int x, int fa) {

    father[x] = fa;

    for (int i = ; i < G[x].size(); i++) {

        p[G[x][i]]--;

    }

    for (int i = ; i < G[x].size(); i++) {

        int v = G[x][i];

        if (p[v] ==  && father[v]==) {

            dfs(v, x);

        }

    }

}

int main() {

#ifndef ONLINE_JUDGE

    freopen("input.txt", "r", stdin);

#endif

    int n;

    scanf("%d", &n);

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

        scanf("%lf%lf%lf", &x[i], &y[i], &r[i]);

    }

    memset(f, , sizeof(f));

    memset(p, , sizeof(p));

    memset(father, , sizeof(father));

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

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

            if (i != j) {

                double d = sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));

                if (r[i] - r[j] >= d) {

                    f[i][j] = ;

                    G[i].push_back(j);

                    f[j][i] = -;

                    p[j]++;

                }

                if (r[j] - r[i] >= d) {

                    f[i][j] = -;

                    f[j][i] = ;

                    G[j].push_back(i);

                    p[i]++;

                }

            }

        }

    }

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

        if (p[i] == ) {

            dfs(i, );

            break;

        }

    }

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

        printf("%d\n", father[i]);

    }

    return ;

}

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

template <class T> class SegmentTree {

public:

    T dat, lazy;

    int leftBorder, rightBorder, mid;

    SegmentTree * leftSon, * rightSon;

    T(* lazyfunc)(T, T);

    T(* mergefunc)(T, T);

    SegmentTree() {

        leftBorder = rightBorder = -;

        leftSon = rightSon = NULL;

    }

    void pushdown();

    void pushup();

    void Build(T *, int, int, T(*)(T, T), T(*)(T, T));

    void Modify(int, int, T);

    T Query(int, int);

    void Free();

};

template<class T> void SegmentTree<T>::pushdown() {

    if (lazy && leftBorder != rightBorder) {

        leftSon->dat = lazyfunc(leftSon->dat, lazy);

        rightSon->dat = lazyfunc(rightSon->dat, lazy);

        leftSon->lazy = lazyfunc(leftSon->lazy, lazy);

        rightSon->lazy = lazyfunc(rightSon->lazy, lazy);

    }

    lazy = (T);

}

template<class T> void SegmentTree<T>::pushup() {

    dat = mergefunc(leftSon->dat, rightSon->dat);

}

template<class T> void SegmentTree<T>::Build(T * S, int l, int r, T(* lfunc)(T, T), T(* mfunc)(T, T)) {

    if (l > r) {

        return;

    }

    lazy = (T);

    leftBorder = l;

    rightBorder = r;

    mid = (leftBorder + rightBorder) >> ;

    lazyfunc = lfunc;

    mergefunc = mfunc;

    if (l == r) {

        dat = S[l];

        return;

    }

    leftSon = new SegmentTree;

    leftSon->Build(S, l, mid, lfunc, mfunc);

    rightSon = new SegmentTree;

    rightSon->Build(S, mid + , r, lfunc, mfunc);

    pushup();

}

template<class T> void SegmentTree<T>::Modify(int l, int r, T NewDat) {

    if (l > r || l < leftBorder || rightBorder < r) {

        return;

    }

    if (leftBorder == l && rightBorder == r) {

        dat = lazyfunc(dat, NewDat);

        lazy = lazyfunc(lazy, NewDat);

        return;

    }

    pushdown();

    if (r <= mid) {

        leftSon->Modify(l, r, NewDat);

    } else if (mid < l) {

        rightSon->Modify(l, r, NewDat);

    } else {

        leftSon->Modify(l, mid, NewDat);

        rightSon->Modify(mid + , r, NewDat);

    }

    pushup();

}

template<class T> T SegmentTree<T>::Query(int l, int r) {

    if (l > r || l < leftBorder || rightBorder < r) {

        return dat;

    }

    pushdown();

    if (l == leftBorder && r == rightBorder) {

        return dat;

    }

    if (r <= mid) {

        return leftSon->Query(l, r);

    } else if (mid < l) {

        return rightSon->Query(l, r);

    } else {

        return mergefunc(leftSon->Query(l, mid), rightSon->Query(mid + , r));

    }

}

template<class T> void SegmentTree<T>::Free() {

    if (leftSon != NULL) {

        leftSon->Free();

    }

    if (rightSon != NULL) {

        rightSon->Free();

    }

    delete leftSon;

    delete rightSon;

}

int lazyfunc(int a, int b) {

    return a + b;

}

int mergefunc(int a, int b) {

    return a > b ? b : a;

}

int n, k;

bool f[];

class tick {

public:

    int t, c;

};

int cmp(const void *x, const void *y) {

    tick * tx = (tick *)x;

    tick * ty = (tick *)y;

    return tx->t > ty->t ?  : -;

}

tick p[];

int index_____[], a[];

SegmentTree<int> st;

int main() {

#ifndef ONLINE_JUDGE

    freopen("input.txt", "r", stdin);

#endif

    memset(a, , sizeof(a));

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

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

        scanf("%d%d", &p[i].t, &p[i].c);

    }

    memset(f, false, sizeof(f));

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

        int s;

        scanf("%d", &s);

        f[s] = true;

    }

    int cnt = ;

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

        if (f[i]) {

            index_____[i] = cnt++;

        }

    }

    qsort(p, n, sizeof(tick), cmp);

    int ptr = , ans = , max = , time = p[].t, s = -;

    st.Build(a, , k - , lazyfunc, mergefunc);

    while (ptr < n) {

        do {

            if (f[p[ptr].c]) {

                st.Modify(index_____[p[ptr].c], index_____[p[ptr].c], );

            } else {

                a[p[ptr].c]++;

                if (a[p[ptr].c] > max) {

                    max = a[p[ptr].c];

                }

            }

            ptr++;

        } while (p[ptr].t == p[ptr - ].t && ptr < n);

        int q = st.Query(, k - );

        if (s == ) {

            ans += p[ptr - ].t - time;

        }

        time = p[ptr - ].t;

        if (q > max) {

            s = ;

        } else {

            s = -;

        }

    }

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

    return ;

}

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

class ink {

public:

    int x, y;

};

int n, k;

int a[][];

bool f[][];

const int dx[] = {-, , , }, dy[] = {, , , -};

ink heap[];

int len;

void adjust_down(int p) {

    if (p *  <= len && a[heap[p].x][heap[p].y] < a[heap[p * ].x][heap[p * ].y]) {

        ink tmp = heap[p];

        heap[p] = heap[p * ];

        heap[p * ] = tmp;

        adjust_down(p * );

    }

    if (p *  +  <= len && a[heap[p].x][heap[p].y] < a[heap[p *  + ].x][heap[p *  + ].y]) {

        ink tmp = heap[p];

        heap[p] = heap[p *  + ];

        heap[p *  + ] = tmp;

        adjust_down(p *  + );

    }

}

void adjust_up(int p) {

    if (p <= ) {

        return;

    }

    if (a[heap[p].x][heap[p].y] > a[heap[p / ].x][heap[p / ].y]) {

        ink tmp = heap[p];

        heap[p] = heap[p / ];

        heap[p / ] = tmp;

        adjust_up(p / );

    }

}

int main() {

#ifndef ONLINE_JUDGE

    freopen("input.txt", "r", stdin);

#endif

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

    memset(f, false, sizeof(f));

    memset(a, , sizeof(a));

    len = ;

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

        ink t;

        int g;

        scanf("%d%d%d", &t.x, &t.y, &g);

        if (g > a[t.x][t.y]) {

            a[t.x][t.y] = g;

            if (!f[t.x][t.y]) {

                heap[++len] = t;

                adjust_up(len);

                f[t.x][t.y] = true;

            }

        }

    }

    while (len > ) {

        ink head = heap[];

        heap[] = heap[len];

        len--;

        adjust_down();

        f[head.x][head.y] = false;

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

            int x = head.x + dx[i], y = head.y + dy[i];

            if (x <  || x >= n || y <  || y >= n) {

                continue;

            }

            if (a[x][y] < a[head.x][head.y] - ) {

                a[x][y] = a[head.x][head.y] - ;

                if (!f[x][y]) {

                    f[x][y] = true;

                    ink p;

                    p.x = x, p.y = y;

                    heap[++len] = p;

                    adjust_up(len);

                }

            }

        }

    }

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

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

            printf("%d ", a[i][j]);

        }

        printf("\n");

    }

    return ;

}

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

#include<vector>

#include<algorithm>

using namespace std;

const long long M = ;

vector<int> G[];

int n, m;

long long common(int u, int v) {

    int iu = , iv = ;

    long long ret = ;

    while (iu < G[u].size() && iv < G[v].size()) {

        if (G[u][iu] == G[v][iv]) {

            iu++, iv++, ret++;

        } else if (G[u][iu] < G[v][iv]) {

            iu++;

        } else {

            iv++;

        }

    }

    return ret;

}

int main() {

#ifndef ONLINE_JUDGE

    freopen("input.txt", "r", stdin);

#endif

    long long ans;

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

        ans = ;

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

            G[i].clear();

        }

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

            int u, v;

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

            G[u].push_back(v);

            G[v].push_back(u);

        }

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

            sort(G[i].begin(), G[i].end());

        }

        int A, B, C, D, E, F;

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

            if (G[A].size() < ) {

                continue;

            }

            for (int i = ; i < G[A].size(); i++) {

                long long p1 = , p2 = , tmp;

                D = G[A][i];

                if (G[D].size() < ) {

                    continue;

                }

                tmp = common(A, D);

                if (tmp >= ) {

                    p1 = tmp * (tmp - ) /  % M;

                }

                tmp = G[D].size() - ;

                if (tmp >= ) {

                    p2 = tmp * (tmp - ) /  % M;

                }

                ans = (ans + p1 * p2) % M;

            }

        }

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

    }

    return ;

}