/*#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")*/
//#pragma GCC optimize("fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
//#pragma GCC optimize("unroll-loops")
//#define _CRT_SECURE_NO_WARNINGS
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
//#pragma GCC optimize("Ofast")
#include <iostream>
#include <vector>
#include <map>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <bitset>
#include <algorithm>
#include <string>
#include <deque>
#include <queue>
#include <math.h>
#include <random>
using namespace std;
typedef int  ll;
typedef pair<ll, ll> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long double ld;
#define all(a) a.begin(), a.end()
#define lb(a, x) lower_bound(a.begin(), a.end(), x)
#define pb(x) push_back(x)
#define fr(i, n) for(int i = 0; i < n; ++i)
//typedef cc_hash_table<int, int, hash<int>> hst2;
//typedef cc_hash_table<int, hst2, hash<int>> hst;
typedef pii ord_set_t;
#ifdef ABCD
typedef map<ord_set_t, vi> ordered_set;
int __builtin_popcount(int x)
{
	int cnt = 0;
	for (; x > 0; x >>= 1) cnt += x & 1;
	return cnt;
}
#else
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
mt19937 rnd(239);
using namespace __gnu_pbds;
typedef tree<
	ord_set_t,
	vi,
	less_equal<ord_set_t>,
	rb_tree_tag,
	tree_order_statistics_node_update>
	ordered_set;
#endif
const int N = 300001;
vi in[N];
int out[N];
bool vis[N];
int dp[N][2];
int cdp[N][2];
bool is_cycle[N];
vi fnd_path(int v)
{
	int u;
	for (u = v;; u = out[u])
	{
		vis[u] = true;
		if (out[u] == -1 || vis[out[u]]) break;
	}
	if (out[u] == -1)
		return vi(1, u);

	v = out[u];
	vi cycle(1, v);
	for (u = out[v]; u != v; u = out[u])
		cycle.push_back(u);
	for (auto it : cycle) is_cycle[it] = true;
	return cycle;
}
void calc_as_root(int v)
{
	vis[v] = true;
	dp[v][0] = 0;
	dp[v][1] = 1;
	for (auto u : in[v])
	{
		if (is_cycle[u]) continue;
		calc_as_root(u);
		dp[v][0] += max(dp[u][0], dp[u][1]);
		dp[v][1] += dp[u][0];
	}
}
int calc_dp(vi &cycle, int flg)
{
	if (cycle.size() == 1)
	{
		return dp[cycle[0]][flg];
	}
	for (auto it : cycle) cdp[it][0] = cdp[it][1] = 0;
	int v = cycle[0];
	cdp[v][flg] = dp[v][flg];
	cdp[v][!flg] = -1000000000;
	for (int i = 1; i < cycle.size(); ++i)
	{
		cdp[cycle[i]][0] = max(cdp[cycle[i - 1]][0], cdp[cycle[i - 1]][1]) + dp[cycle[i]][0];
		cdp[cycle[i]][1] = cdp[cycle[i - 1]][0] + dp[cycle[i]][1];
	}
	if (flg == 1)
		return cdp[cycle.back()][0];
	return max(cdp[cycle.back()][1], cdp[cycle.back()][0]);
}
int solve(int v)
{
	vi cycle = fnd_path(v);
	for (auto it : cycle) 
		calc_as_root(it);
	return max(calc_dp(cycle, 0), calc_dp(cycle, 1));
}
int main()
{

	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifdef ABCD
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#else

#endif
	int a, b; cin >> a >> b;
	if (abs(a - b) & 1) cout << "IMPOSSIBLE ";
	else  cout << abs(a + b) / 2;
}


Measured memory_bytes: 7552