#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int* parent;
    int* rank;
    int n;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->n = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionNodes(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    if (px == py) return;
    
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
}

void freeUnionFind(UnionFind* uf) {
    free(uf->parent);
    free(uf->rank);
    free(uf);
}

int compareMeetings(const void* a, const void* b) {
    int* meetingA = *(int**)a;
    int* meetingB = *(int**)b;
    return meetingA[2] - meetingB[2];
}

int* findAllPeople(int n, int** meetings, int meetingsSize, int* meetingsColSize, int firstPerson, int* returnSize) {
    // Sort meetings by time
    qsort(meetings, meetingsSize, sizeof(int*), compareMeetings);
    
    bool* knowsSecret = (bool*)calloc(n, sizeof(bool));
    knowsSecret[0] = true;
    knowsSecret[firstPerson] = true;
    
    int i = 0;
    while (i < meetingsSize) {
        int currentTime = meetings[i][2];
        int start = i;
        
        // Find all meetings at current time
        while (i < meetingsSize && meetings[i][2] == currentTime) {
            i++;
        }
        
        // Create union-find for this time period
        UnionFind* uf = createUnionFind(n);
        bool* peopleAtTime = (bool*)calloc(n, sizeof(bool));
        
        for (int j = start; j < i; j++) {
            int x = meetings[j][0], y = meetings[j][1];
            unionNodes(uf, x, y);
            peopleAtTime[x] = peopleAtTime[y] = true;
        }
        
        // Check each person and their component
        bool* processed = (bool*)calloc(n, sizeof(bool));
        for (int person = 0; person < n; person++) {
            if (!peopleAtTime[person] || processed[person]) continue;
            
            int root = find(uf, person);
            bool componentHasSecret = false;
            
            // Check if anyone in this component has secret
            for (int other = 0; other < n; other++) {
                if (peopleAtTime[other] && find(uf, other) == root) {
                    processed[other] = true;
                    if (knowsSecret[other]) {
                        componentHasSecret = true;
                    }
                }
            }
            
            // If component has secret, give it to everyone
            if (componentHasSecret) {
                for (int other = 0; other < n; other++) {
                    if (peopleAtTime[other] && find(uf, other) == root) {
                        knowsSecret[other] = true;
                    }
                }
            }
        }
        
        free(peopleAtTime);
        free(processed);
        freeUnionFind(uf);
    }
    
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = 0;
    for (int i = 0; i < n; i++) {
        if (knowsSecret[i]) {
            result[(*returnSize)++] = i;
        }
    }
    
    free(knowsSecret);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}