#include <iostream>
#include <vector>
#include <algorithm>
#include <set>

class DSU {
    std::vector<int> dsu;
    std::vector<int> sizes;
    std::vector<int> smallest;
    int result = 0;
    bool updated = true;
    std::set<int> even;
    std::set<int> odd;

public:
    DSU(int n) {
        for (int i = 0; i < n; ++i) {
            dsu.push_back(i);
            smallest.push_back(i);
            odd.insert(i);
        }
        sizes.resize(n, 1);
    }

    int find_root(int a) {
        if (dsu[a] == a) {
            return a;
        }
        return dsu[a] = find_root(dsu[a]);
    }

    void union_dsu(int a, int b) {
        a = find_root(a);
        b = find_root(b);
        if (a != b) {
            updated = false;
            if (sizes[b] < sizes[a]) {
                dsu[b] = a;
                if (sizes[b] % 2 == 1) {
                    odd.erase(b);
                    if (sizes[a] % 2 == 0) {
                        even.erase(a);
                        odd.insert(a);
                    } else {
                        odd.erase(a);
                        even.insert(a);
                    }
                } else {
                    even.erase(b);
                }
                sizes[a] += sizes[b];
                smallest[a] = std::min(smallest[a], smallest[b]);
            } else {
                dsu[a] = b;
                if (sizes[a] % 2 == 1) {
                    odd.erase(a);
                    if (sizes[b] % 2 == 0) {
                        even.erase(b);
                        odd.insert(b);
                    } else {
                        odd.erase(b);
                        even.insert(b);
                    }
                } else {
                    even.erase(a);
                }
                sizes[b] += sizes[a];
                smallest[b] = std::min(smallest[a], smallest[b]);
            }
        }
    }

    int city() {
        if (updated) {
            if (result == -1) {
                return -1;
            }
            return result + 1;
        }
        int res = dsu.size();
        for (auto i : odd) {
            if (smallest[i] < res) {
                res = smallest[i];
            }
        }
        updated = true;
        if (res == dsu.size()) {
            result = -1;
            return -1;
        } else {
            result = res;
            return result + 1;
        }
    }
};

int main() {
    int n, m;
    std::cin >> n >> m;
    DSU dsu(n);
    char command;
    int a, b;
    for (int i = 0; i < m; ++i) {
        std::cin >> command;
        if (command == 'a') {
            std::cin >> a >> b;
            dsu.union_dsu(a - 1, b - 1);
        } else {
            std::cout << dsu.city() << '\n';
        }
    }
}