#include <iostream>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <cstring>
#include <sstream>
#include <iomanip>
#include <new>
#define ESP (1e-13)
#define INF 2000000000
/*
#define FOR(i,m,n)    for(int i=m;i<n;i++)
#define FORB(i,m,n)    for(int i=m;i>=n;i--)
#define INF 999999999
*/

#define ll long long
/*
#define PUSH(a) push_back(a)
#define POP() pop_back()
#define SORT(v,n) sort(v,v+n)
#define VSORT(v) sort(v.begin(),v.end())
*/

using namespace std;

int dy[] = { 0,0,1,-1 };
int dx[] = { 1,-1,0,0 };

typedef struct {
	long int A;
	long int B;
}Item ;

Item item[100000];
int N, W,K;
int C[100001][32], G[100001][32];

void compute(int &maxValue, vector<int> &selection) {
	for (int w = 0;w <= W;w++) {
		C[0][w] = 0;
		G[0][w] = 1;
	}
	for (int i = 1;i <= N;i++) C[i][0] = 0;
	for (int i = 1;i <= N;i++) {
		for (int w = 1;w <= W;w++) {
			C[i][w] = C[i - 1][w];
			G[i][w] = 0;
			if (item[i].A > w) continue;
			if (item[i].B + C[i - 1][w - item[i].A] > C[i - 1][w]) {
				C[i][w] = item[i].B + C[i - 1][w - item[i].A];
				G[i][w] = 1;
			}
		}
	}
	maxValue = C[N][W];
	selection.clear();
	for (int i = N, w = W;i >= 1;i--) {
		if (G[i][w] == 1) {
			selection.push_back(i);
			w -= item[i].A;
		}
   }
	reverse(selection.begin(), selection.end());
}

void input() {
	cin >> N >> W;
	for (int i = 0;i < N;i++) {
		cin >>item[i].A; cin >> item[i].B;
	}

}

//座標点の構造体
typedef struct Point {
	double x;
	double y;

	Point() { }

	Point(double x, double y) :x(x), y(y) { }

	Point operator+(const Point& p) {
		return Point(x + p.x, y + p.y);
	}

	Point operator-(const Point& p) {
		return Point(x - p.x, y - p.y);
	}

	Point operator*(const double& a) {
		return Point(x*a, y*a);
	}

	Point operator/(const double& a) {
		return Point(x / a, y / a);
	}

	Point operator=(const Point& p1) {
		return Point(p1.x, p1.y);
	}

};

//ヴェクトルの構造体
typedef Point Vector;

//直線の構造体
struct Line {
	Point p1, p2;
	Line() {}
	Line(const Point& a, const Point& b) : p1(a), p2(b) { }
	Line operator=(const Line& l) {
		return Line(l.p1, l.p2);
	}
};

//線分の構造体
typedef Line Segment;

//円の構造体
struct Circle {
	Point c;
	double r;
	Circle() { }
	Circle(const Point& p, const double& r) : c(p), r(r) { }
};

//2点間の距離を求める関数
double abs(Point p1, Point p2) {
	double norm = (p1.x - p2.x)*(p1.x - p2.x) + (p1.y - p2.y)*(p1.y - p2.y);
	return sqrt(norm);
}

//内積関数
double product(Vector v1, Vector v2) {
	return v1.x*v2.x + v1.y*v2.y;
}

//外積関数
double cross(Vector p1, Vector p2) {
	return p1.x*p2.y - p1.y*p2.x;
}

//3点の位置関係を求める関数
int ccw(Point p0, Point p1, Point p2) {
	Vector v0 = p1 - p0;
	Vector v1 = p2 - p0;
	if (cross(v0, v1) > ESP) return 1;   //p0,p1,p2が反時計回り
	if (cross(v0, v1) < -ESP) return -1;   //p0,p1,p2が時計回り
	if (product(v0, v1) < -ESP) return 2;  //p2,p0,p1の順で同一直線上
	if (abs(p0, p1) < abs(p0, p2)) return -2;  //p0,p1,p2の順で同一直線上
	return 0;   //p2が線分(p0,p1)上
}

//或る点の直線に対する射影の座標を求める関数
Point project(Segment s, Point p) {
	Vector base = s.p2 - s.p1;
	double x = abs(base, Point(0.0, 0.0))*abs(base, Point(0.0, 0.0));
	double r = product(p - s.p1, base) / x;
	return s.p1 + base*r;
}

//線分ｓを対象軸とした点ｐの線対称点の座標を求める関数
Point reflect(Segment s, Point p) {
	return (project(s, p) - p)*2.0 + p;
}


bool intersect(Point p0, Point p1, Point p2, Point p3) {
	return (ccw(p0, p1, p2)*ccw(p0, p1, p3) <= 0 && ccw(p2, p3, p0)*ccw(p2, p3, p1) <= 0);
	//２線分が交差する条件
}

//２線分が交わっているか判定する関数
bool intersect(Segment s1, Segment s2) {
	return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}

//直線と点の距離を求める関数
double DistanceLP(Line l, Point p) {
	return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p1, l.p2));
}

//線分と点の距離を求める関数
double DistanceSP(Segment s, Point p) {
	if (product(s.p2 - s.p1, p - s.p1) < -ESP) return abs(p, s.p1);
	if (product(s.p1 - s.p2, p - s.p2) < -ESP) return abs(p, s.p2);
	return DistanceLP(s, p);
}

//2線分の距離を求める関数
double DistanceSS(Segment s1, Segment s2) {
	if (intersect(s1, s2)) return 0.0;
	return min(min(DistanceSP(s1, s2.p1), DistanceSP(s1, s2.p2)), min(DistanceSP(s2, s1.p1), DistanceSP(s2, s1.p2)));
}

//２直線の好転を求める関数
Point CrossPoint(Line s1, Line s2) {
	double d1 = DistanceLP(s2, s1.p1);
	double d2 = DistanceLP(s2, s1.p2);
	double t = d1 / (d1 + d2);
	return s1.p1 + (s1.p2 - s1.p1)*t;
}

//円と直線の交差判定をする関数
bool intersect(Circle c, Line l) {
	return DistanceLP(l, c.c) < c.r;
}

//円と直線の交点を求める関数
pair<Point, Point> CrossPoints(Circle c, Line l) {
	Vector prpr = project(l, c.c);
	Vector hshs = (l.p2 - l.p1) / abs(l.p2, l.p1);
	double base = sqrt(c.r*c.r - abs(c.c, prpr)*abs(c.c, prpr));
	return make_pair(prpr - hshs*base, prpr + hshs*base);
}

//偏角と極
double arg(Vector p) { return atan2(p.y, p.x); }
Vector polar(double a, double r) { return Point(cos(r)*a, sin(r)*a); }

//円と円の交点を求める関数
pair<Point, Point> CrossPoints(Circle c1, Circle c2) {
	double d = abs(c1.c, c2.c);
	double a = acos((c1.r*c1.r + d*d - c2.r*c2.r) / (2 * c1.r*d)); //余弦定理
	double t = arg(c2.c - c1.c);
	return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}

//2直線の位置関係を求める関数群
//直交判定
bool isOrth(Vector a, Vector b) {
	return abs(product(a, b)) < ESP;
}
bool isOrth(Point a1, Point a2, Point b1, Point b2) {
	return isOrth(a1 - a2, b1 - b2);
}
bool isOrth(Segment s1, Segment s2) {
	return isOrth(s1.p2, s1.p1, s2.p2, s2.p1);
}
//平行判定
bool isPara(Vector a, Vector b) {
	return abs(cross(a, b)) < ESP;
}
bool isPara(Point a1, Point a2, Point b1, Point b2) {
	return isPara(a1 - a2, b1 - b2);
}
bool isPara(Segment s1, Segment s2) {
	return isPara(s1.p2, s1.p1, s2.p2, s2.p1);
}


int main() {
	int A,B,C;
	cin >> A;
	cin >> B;
	cin >> C;
	if (A == B) cout << C << endl;
	else if (B == C) cout << A << endl;
	else cout << B << endl;

}



Measured memory_bytes: 256