#include <iostream>
#include <algorithm>
using namespace std;
int a[3];
int main() {
    cin >> a[0] >> a[1] >> a[2];
    sort(a, a + 3);
    int d1 = a[1] - a[0];
    int d2 = a[2] - a[1];

    if (d1 == d2) {
        // Trường hợp đều: số thiếu có thể là a[0]-d1 hoặc a[2]+d1
        // Chọn số lớn nhất
        cout << max(a[0] - d1, a[2] + d1);
    } else if (d1 > d2) {
        // Khoảng cách lớn ở bên trái, số thiếu là a[0] - d1
        // Hoặc hiểu theo cách khác: d1 = 2*d2, số thiếu là a[1] - d2
        cout << a[1] - d2;
    } else {
        // Khoảng cách lớn ở bên phải, số thiếu là a[2] + d2
        // Hoặc: d2 = 2*d1, số thiếu là a[1] + d1
        cout << a[1] + d1;
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    long long x[3];
    cin >> x[0] >> x[1] >> x[2];
    vector<long long> nums = {x[0], x[1], x[2]};
    sort(nums.begin(), nums.end());

    long long ans = -40000000000LL; // Khởi tạo giá trị nhỏ

    // Duyệt các vị trí có thể có của số thiếu (0, 1, 2, 3)
    for (int missing_pos = 0; missing_pos <= 3; missing_pos++) {
        vector<long long> full;
        int ptr = 0;
        // Xây dựng dãy 4 số
        for (int i = 0; i < 4; i++) {
            if (i == missing_pos) {
                // Để trống, ta sẽ tính toán số này sau
                full.push_back(-1);
            } else {
                full.push_back(nums[ptr++]);
            }
        }

        // Nếu vị trí thiếu là 0 hoặc 3, ta có thể suy ra số thiếu ngay
        if (missing_pos == 0) {
            long long k = full[1] - full[2]; // Khoảng cách lấy từ 2 số cuối
            long long missing = full[1] - k;
            ans = max(ans, missing);
        } else if (missing_pos == 3) {
            long long k = full[1] - full[0]; // Khoảng cách lấy từ 2 số đầu
            long long missing = full[2] + k;
            ans = max(ans, missing);
        } else {
            // Nếu thiếu ở giữa (vị trí 1 hoặc 2)
            // Khoảng cách từ số thứ 0 đến 3 (trừ vị trí thiếu)
            // Giả sử full[0] và full[3] đã được điền đúng vị trí
            // Tính k dựa trên khoảng cách giữa 2 số đầu tiên (hoặc cuối) trong dãy đã được điền
            // Nhưng cách này hơi phức tạp để điền vào mảng full đúng vị trí.
            // 
            // Đơn giản hơn: Thử 4 trường hợp Missing Value M
            // Tạo dãy 4 số bao gồm M và 3 số cho trước.
            // Sắp xếp dãy đó.
            // Kiểm tra xem có phải CSC không.
        }
    }

    // Code đơn giản hóa cho approach Brute Force thực thụ:
    vector<long long> inputs = {x[0], x[1], x[2]};
    // Chỉ cần thử các giá trị M logic:
    // 1. M = 2*inputs[0] - inputs[1]
    // 2. M = 2*inputs[1] - inputs[0] (hoặc inputs[2])
    // 3. M = 2*inputs[2] - inputs[1]
    // ... và các biến thể.
    // Tuy nhiên, do Input nhỏ, có thể thử tất cả các vị trí.

    // Code tối ưu cho Brute Force:
    vector<long long> candidates;
    // Giả sử inputs đã sort: a, b, c
    long long a = nums[0], b = nums[1], c = nums[2];

    // Các vị trí có thể:
    // 1. Thiếu trước a: a - (b-a)
    // 2. Thiếu giữa a-b: a + (b-a)/2 (nếu chia hết)
    // 3. Thiếu giữa b-c: b + (c-b)/2 (nếu chia hết)
    // 4. Thiếu sau c: c + (c-b)

    // Đơn giản nhất là dùng phép chia lấy dư
    // Thử 4 vị trí

    return 0;
}

#include <iostream>
#include <vector>
#include <numeric>
#include <cmath>
#include <algorithm>
using namespace std;

int main() {
    long long x[3];
    cin >> x[0] >> x[1] >> x[2];
    // Tính tổng và tổng bình phương của 3 số cho trước
    long long S = x[0] + x[1] + x[2];
    long long S2 = x[0]*x[0] + x[1]*x[1] + x[2]*x[2];

    // Giả sử dãy CSC là: a, a+k, a+2k, a+3k
    // Tổng 4 số: 4a + 6k = T (tổng 4 số)
    // Tổng bình phương 4 số: 4a^2 + 12ak + 14k^2 = P (tổng bình phương 4 số)
    // Biết S và S2, ta có: T = S + M, P = S2 + M^2
    // Thay vào phương trình tổng:
    // 4a + 6k = S + M  (1)
    // 4a^2 + 12ak + 14k^2 = S2 + M^2 (2)
    // Từ (1): 2a = (S+M - 6k) / 2
    // Thay vào (2) giải phương trình bậc 2 tìm k, sau đó tìm M.
    // Tuy nhiên, do k phải là số nguyên, ta có thể duyệt k.
    // Nhưng k có thể âm và lớn.
    // 
    // Cách tiếp cận này quá phức tạp so với bài này.
    // Chỉ để minh họa tính đa dạng.
    // Trong thực tế, bài này chỉ cần logic chênh lệch.
    cout << 0; 
    return 0;
}