位运算：整数就是一排开关，以及 lowbit 为什么成立

// 标准答案：对每个数，数一遍它出现了几次 —— O(n²)
//
// ★ 它和正解的思路**完全不同**（第 20 章那条：同一个思路写两遍只能验出打字错误）：
//   正解靠的是异或的代数性质，这一份从头到尾没碰过任何一个位。
//   所以它当对拍的标准答案是合格的。
//
// ⚠ m = 2×10⁶ 时它要做 4×10¹² 次比较 —— 按第 45 章那张表估，是几个小时。
//   所以它只在小数据上当裁判。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int m;
    cin >> m;
    vector<int> a(m);
    for (int i = 0; i < m; i++) cin >> a[i];

    for (int i = 0; i < m; i++) {
        int cnt = 0;
        for (int j = 0; j < m; j++) if (a[j] == a[i]) cnt++;
        if (cnt == 1) { cout << a[i] << '\n'; return 0; }
    }
    cout << -1 << '\n';                      // 题面保证有解，走不到这里
    return 0;
}

// 做法二：排完序，相同的两个一定挨在一起 —— O(n log n)
//
// 排序之后从头两个两个地看：只要 a[i] != a[i+1]，落单的就是 a[i]。
// 走到最后都成对，那落单的就是最后一个。
//
// ⚠ 这一份里藏着这一章的头号坑：判断「下标是不是偶数」时，
//   `i & 1 == 0` 是错的（`==` 比 `&` 优先级高，见 wrongPri.cpp）。
//   这里老老实实写成 `(i & 1) == 0`，括号一个都不能省。
//
// 空间：要把 m 个数全存下来（m = 2×10⁶ 时 8 MB），而且排序本身还要 O(n log n) 时间。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int m;
    cin >> m;
    vector<int> a(m);
    for (int i = 0; i < m; i++) cin >> a[i];
    sort(a.begin(), a.end());

    for (int i = 0; i + 1 < m; i += 2)
        if (a[i] != a[i + 1]) { cout << a[i] << '\n'; return 0; }

    cout << a[m - 1] << '\n';                // 前面全成对 ⇒ 落单的是最后一个
    return 0;
}

// 做法三：开一个「每个长度出现几次」的计数数组 —— O(n) 时间，但**空间会要命**
//
// 想法本身没错，而且是很多人的第一反应。问题全在那一句声明上：
//     题面说长度最大 10⁸  ⇒  int cnt[100000001]  =  4×10⁸ 字节 = 381 MiB
// 而题目给的内存限制是 **256 MiB**。⇒ **MLE**，一个字节都没超时就死了。
//
// ★★ 而它在开发机上是**跑得完的**（内存够）—— 这正是第 45 章那句话的第二现场：
//   **本机跑得过 ≠ 评测机跑得过。** 所以这一份会把峰值内存打出来给你看。
//
// ⚠ 有人会说：把 int 换成 char（只要记奇偶）不就 95 MiB 了吗？对，能过。
//   但那已经是在**跟内存限制赛跑**了 —— 而正解只要 8 个字节，连数组都不用开。
//
// 用法：./bucket [值域上限]   默认 100000000（题面那个）。
//   ⚠ 想在页面上快点跑完，把它调小（比如 1000000）——
//     调小之后它就是一份完全正常的 O(n) 解法，这也说明问题从来不在算法上，在那句声明上。

#include <bits/stdc++.h>
using namespace std;

/** 从 /proc/self/status 读峰值内存（VmHWM，单位 KB）—— 和第 45 章 mle.cpp 同一招 */
static long long peakKb() {
    FILE* f = fopen("/proc/self/status", "r");
    if (!f) return -1;
    char line[256];
    long long kb = -1;
    while (fgets(line, sizeof(line), f))
        if (strncmp(line, "VmHWM:", 6) == 0) { sscanf(line + 6, "%lld", &kb); break; }
    fclose(f);
    return kb;
}

int main(int argc, char** argv) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int lim = (argc > 1) ? atoi(argv[1]) : 100000000;
    if (lim < 1) lim = 1;

    int m;
    cin >> m;
    vector<int> cnt((size_t)lim + 1, 0);      // ← 要命的就是这一行
    int ans = -1;
    for (int i = 0; i < m; i++) {
        int x;
        cin >> x;
        if (x >= 0 && x <= lim) cnt[x]++;
    }
    for (int v = 0; v <= lim; v++) if (cnt[v] == 1) { ans = v; break; }

    fprintf(stderr, "计数数组开到 %d：要 %.0f MiB，此刻峰值内存 %.1f MiB\n",
            lim, ((double)lim + 1) * sizeof(int) / 1048576.0, peakKb() / 1024.0);
    cout << ans << '\n';
    return 0;
}

// 正解：把所有数异或起来，剩下的就是答案 —— O(n) 时间，O(1) 空间
//
// 靠的是异或的三条性质（verify.cpp 里当场验了两万组）：
//     ① a ^ a = 0        —— 一样的两个数，异或掉就没了
//     ② a ^ 0 = a        —— 和 0 异或不变
//     ③ 可交换、可结合    —— 所以「先后顺序无所谓」，随便怎么凑对都行
//
// 于是把 2n+1 个数全部异或起来：n 对相同的各自变成 0（性质 ①、③），
// 0 再和落单的那个异或还是它自己（性质 ②）。**一个循环，一个变量。**
//
// ★ 注意它比另外三种做法少的不只是时间：它**一个数组都不用开**，
//   甚至可以边读边算 —— 这在 m 达到 2×10⁶ 时是实打实的差别（见第 6 步那张内存表）。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int m;
    cin >> m;
    int res = 0, x;
    for (int i = 0; i < m; i++) { cin >> x; res ^= x; }
    cout << res << '\n';
    return 0;
}

// 位运算工具箱：七个最常用的动作，每个都是一行
//
// 输入：第一行 q，接下来 q 行，每行 `op x k`（low / cnt / half 用不到 k，随便填一个）
//   get   x k   取 x 的第 k 位（0 或 1）
//   set   x k   把第 k 位置成 1
//   clr   x k   把第 k 位清成 0
//   flip  x k   把第 k 位翻过来
//   low   x     lowbit(x)：最低位的那个 1（连同它后面的 0）
//   cnt   x     popcount(x)：二进制里有几个 1
//   half  x     x 除以 2（★ 负数在这儿咬人，见 wrongHalf.cpp）
// 输出：每行一个结果。
//
// ★★ 两处写法是**有意**的，它们就是这一章要讲的东西：
//
// 一、**位运算一律在 unsigned long long 上做。** 有符号数的符号位交给位运算，
//     C++17 里是「实现定义」的（C++20 才把补码写进标准）。第 44 章那条规矩在这儿又用一次：
//     **要可复现，就别把边界交给未定义 / 实现定义的行为。**
//
// 二、**换回有符号数时，那两行就是补码的定义**（toSigned 里）：
//         最高位（第 63 位）的权重是 −2⁶³，其余第 i 位是 +2^i。
//     这本书不单列一节讲原码 / 反码 / 补码 —— 它只在**非讲不可**的地方出现，
//     而这里和 lowbit 就是那两处。
//
// 位号 k 限定在 [0, 62]：不碰符号位，省得每个操作都要单独讨论一遍。

#include <bits/stdc++.h>
using namespace std;

/** 补码：最高位的权重是 −2⁶³，其余是 +2^i */
static long long toSigned(unsigned long long u) {
    const unsigned long long TOP = 1ull << 63;
    if (u < TOP) return (long long)u;
    return (long long)(u - TOP) - 9223372036854775807LL - 1;   // 减掉 2⁶³，不溢出地减
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int q;
    if (!(cin >> q)) return 0;
    string op;
    long long x;
    int k;
    while (q-- && (cin >> op >> x >> k)) {
        if (k < 0) k = 0;
        if (k > 62) k = 62;
        unsigned long long u = (unsigned long long)x;        // 这一步是有定义的：对 2⁶⁴ 取模
        unsigned long long bit = 1ull << k;

        if (op == "get")       cout << ((u >> k) & 1ull) << '\n';
        else if (op == "set")  cout << toSigned(u | bit) << '\n';
        else if (op == "clr")  cout << toSigned(u & ~bit) << '\n';
        else if (op == "flip") cout << toSigned(u ^ bit) << '\n';
        else if (op == "low")  cout << toSigned(u & (~u + 1ull)) << '\n';   // 就是 x & -x
        else if (op == "cnt")  cout << __builtin_popcountll(u) << '\n';
        else if (op == "half") cout << x / 2 << '\n';        // 是除法，不是 >> 1
        else                   cout << "?" << '\n';
    }
    return 0;
}

// ★ 口诀复核：「位运算比算术快」到底成不成立
//
// 这句口诀几乎是每个人学位运算时听到的第一句话。这本书的立场一向是「口诀要拿实测复核」
// （第 29、32、33、34、41、45 章各犯过一次），所以这一章也现场量。
//
// 四对写法，每一对都量两件事 —— **一样快吗** 和 **结果一样吗**：
//     ① 无符号   x * 2   vs  x << 1
//     ② 无符号   x % 2   vs  x & 1
//     ③ 有符号   x % 2   vs  x & 1        ★ 负数上结果**不一样**
//     ④ 有符号   x / 2   vs  x >> 1       ★ 负奇数上结果**不一样**
//
// ⇒ 预告结论（别背，看下面跑出来的数）：**前两对一样快** —— 编译器早就把 `* 2` 换成移位了。
//   位运算真正值钱的地方从来不是这里，而是③④那两行「结果不一样」。
//
// ⚠ 防编译器的写法和第 45 章 ops.cpp 一样：结果必须累加进 volatile，
//   否则整个循环会被当成死代码删掉，量出来是 0 秒。
//
// 用法：./speed [每个内核的目标毫秒数，默认 200] [csv]

#include <bits/stdc++.h>
#include <chrono>
using namespace std;
using namespace std::chrono;

static const int N = 1 << 16;
static vector<int> a;                       // 有正有负
static volatile long long sink = 0;

static string padDisp(const string& s, int width) {
    int disp = 0;
    for (unsigned char c : s) {
        if ((c & 0xC0) == 0x80) continue;
        disp += (c < 0x80) ? 1 : 2;
    }
    return s + string(max(0, width - disp), ' ');
}

/** 同上，补在左边（右对齐用） */
static string padLeftDisp(const string& s, int width) {
    int disp = 0;
    for (unsigned char c : s) {
        if ((c & 0xC0) == 0x80) continue;
        disp += (c < 0x80) ? 1 : 2;
    }
    return string(max(0, width - disp), ' ') + s;
}

template <class F>
double bench(F kernel, double targetMs) {
    double ms = 0;
    long long ops = 0;
    auto t0 = steady_clock::now();
    while (ms < targetMs) {
        sink += kernel();
        ops += N;
        ms = duration<double, milli>(steady_clock::now() - t0).count();
    }
    return ops / (ms / 1000.0);
}

int main(int argc, char** argv) {
    double targetMs = (argc > 1) ? atof(argv[1]) : 200.0;
    bool csv = (argc > 2 && string(argv[2]) == "csv");
    if (targetMs < 1) targetMs = 1;

    a.resize(N);
    /* ⚠ 数据里必须有**负的奇数**，否则最后两行的「结果一样吗」会假绿：
       第一版写的是 (i*37)%100000+1，负数那一半正好全是偶数，两种写法当然一样。 */
    {
        unsigned seed = 20260825u;
        for (int i = 0; i < N; i++) {
            seed = seed * 1103515245u + 12345u;
            int mag = (int)((seed >> 8) % 100000u) + 1;
            a[i] = (i % 2) ? -mag : mag;                                     // 一半负数，奇偶都有
        }
    }

    double v[8];
    v[0] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += (unsigned)a[i] * 2u; return s; }, targetMs);
    v[1] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += (unsigned)a[i] << 1; return s; }, targetMs);
    v[2] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += (unsigned)a[i] % 2u; return s; }, targetMs);
    v[3] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += (unsigned)a[i] & 1u; return s; }, targetMs);
    v[4] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += a[i] % 2; return s; }, targetMs);
    v[5] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += a[i] & 1; return s; }, targetMs);
    v[6] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += a[i] / 2; return s; }, targetMs);
    v[7] = bench([&] { long long s = 0; for (int i = 0; i < N; i++) s += a[i] >> 1; return s; }, targetMs);

    /* 结果一样吗：拿同一批数据逐个比 */
    bool same[4] = { true, true, true, true };
    for (int i = 0; i < N; i++) {
        unsigned u = (unsigned)a[i];
        if (u * 2u != (u << 1)) same[0] = false;
        if (u % 2u != (u & 1u)) same[1] = false;
        if (a[i] % 2 != (a[i] & 1)) same[2] = false;
        if (a[i] / 2 != (a[i] >> 1)) same[3] = false;
    }

    const char* name[4] = { "无符号   x * 2   vs  x << 1",
                            "无符号   x % 2   vs  x & 1",
                            "有符号   x % 2   vs  x & 1",
                            "有符号   x / 2   vs  x >> 1" };
    if (csv) {
        const char* key[4] = { "mul2", "mod2u", "mod2s", "div2s" };
        for (int p = 0; p < 4; p++)
            printf("%s,%.4e,%.4e,%d\n", key[p], v[p * 2], v[p * 2 + 1], same[p] ? 1 : 0);
        return 0;
    }

    printf("位运算真的更快吗？（本机实测，每个内核跑约 %.0f 毫秒）\n\n", targetMs);
    printf("  %s %s %s %s %s\n", padDisp("两种写法", 30).c_str(),
           padLeftDisp("算术 次/秒", 12).c_str(), padLeftDisp("位运算 次/秒", 12).c_str(),
           padLeftDisp("快多少", 11).c_str(), padLeftDisp("结果一样吗", 12).c_str());
    for (int p = 0; p < 4; p++)
        printf("  %s %12.2e %12.2e %8.2f 倍 %s\n", padDisp(name[p], 30).c_str(),
               v[p * 2], v[p * 2 + 1], v[p * 2 + 1] / v[p * 2],
               padLeftDisp(same[p] ? "一样" : "★ 不一样", 12).c_str());

    printf("\n★ 前两行「快多少」都在 1.0 上下 —— 编译器早就把 * 2 和 %% 2 换成移位和与了。\n");
    printf("★★ 真正的差别在最后两行的**最右边一列**：那已经不是快慢问题，是**算的不是同一件事**。\n");
    printf("   -7 %% 2 = %d，而 -7 & 1 = %d；-7 / 2 = %d，而 -7 >> 1 = %d。\n",
           -7 % 2, -7 & 1, -7 / 2, -7 >> 1);
    return 0;
}

// 正解：把所有数异或起来，剩下的就是答案 —— O(n) 时间，O(1) 空间
//
// 靠的是异或的三条性质（verify.cpp 里当场验了两万组）：
//     ① a ^ a = 0        —— 一样的两个数，异或掉就没了
//     ② a ^ 0 = a        —— 和 0 异或不变
//     ③ 可交换、可结合    —— 所以「先后顺序无所谓」，随便怎么凑对都行
//
// 于是把 2n+1 个数全部异或起来：n 对相同的各自变成 0（性质 ①、③），
// 0 再和落单的那个异或还是它自己（性质 ②）。**一个循环，一个变量。**
//
// ★ 注意它比另外三种做法少的不只是时间：它**一个数组都不用开**，
//   甚至可以边读边算 —— 这在 m 达到 2×10⁶ 时是实打实的差别（见第 6 步那张内存表）。

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int m;
    cin >> m;
    int res = 0, x;
    for (int i = 0; i < m; i++) { cin >> x; res ^= x; }
    cout << res << '\n';
    return 0;
}