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

#define pb push_back
#define eb emplace_back
#define mk make_pair
#define fi first
#define se second
#define mset(a, b) memset(a, b, sizeof(a))
using ll = long long;
using pii = pair<int, int>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template<class Ty> Ty randint(Ty a, Ty b) { return uniform_int_distribution<Ty>(a, b)(rng); }

template<class T> void DBG(T&& x) { cerr << x << " "; }
template<class T, class...Args> void DBG(T&& x, Args&&... args) { DBG(x); DBG(args...); }
#define DBG(...) { cerr << "[" << #__VA_ARGS__ << "]: "; DBG(__VA_ARGS__); cerr << endl; }
template<class num> inline void rd(num& x) { cin >> x; }
template <class Ty, class... Args> inline void rd(Ty& x, Args&... args) { rd(x); rd(args...); }
template<class num> inline void print(num&& x) { cout << x; }
template <class Ty, class... Args> inline void print(Ty&& x, Args&&... args) { print(x); print(' '); print(args...); }
#define print(...) { print(__VA_ARGS__); print('\n'); }

struct Solver {
	const int MAXN = 2e5 + 5, INF = 0x3f3f3f3f;

	inline void run_test(int test_case) {
		int n; rd(n);
		vector<pair<string, bool>> a(n);
		for (int i = 0; i < n; i++) {
			string s; rd(s);
			if (s[0] == '!') {
				s.erase(s.begin(), s.begin()+1);
				a[i] = {s, true};
			} else {
				a[i] = {s, false};
			}
		}

		sort(a.begin(), a.end());

		string ans = "satisfiable";
		for (int i = 0; i + 1 < n; i++) {
			if (a[i].fi == a[i+1].fi && a[i].se != a[i+1].se) ans = a[i].fi;
		}

		print(ans);
	}

	inline void prepare() { // first thing to run
		ios::sync_with_stdio(false); cin.tie(nullptr);
	}
};

/* **************************************************** */

// CHANGE HERE if there are multiple test cases
const enum TEST_TYPE { SINGLE, MULTIPLE, MULTIPLE_EOF } test_type = SINGLE;

inline void go_for_it() {
	if (test_type == SINGLE) {
		Solver solver;
		solver.prepare();
		solver.run_test(1);
	} else if (test_type == MULTIPLE) {
		Solver solver;
		solver.prepare();
		int test_count; rd(test_count);
		for (int test_number = 1; test_number <= test_count; test_number++)
			solver.run_test(test_number);
	} else {
		Solver solver;
		solver.prepare();
		for (int test_number = 1;; test_number++)
			solver.run_test(test_number);
	}
}

int main() {
    go_for_it();
}

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;

#define rep(i,n) for (long long i = 0; i < (n); ++i)
#define INF LONG_MAX/3
//#define DIV 1000000007
//#define DIV 998244353

template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};

struct UnionFind
{
  // par[i]：データiが属する木の親の番号。i == par[i]のとき、データiは木の根ノードである
  vector<int> par;
  // sizes[i]：根ノードiの木に含まれるデータの数。iが根ノードでない場合は無意味な値となる
  vector<int> sizes;

  UnionFind(int n) : par(n), sizes(n, 1) {
	  // 最初は全てのデータiがグループiに存在するものとして初期化
	  for(int i = 0; i < n; i++){
		  par[i] = i;
	  }
  }

  // データxが属する木の根を得る
  int find(int x) {
    if (x == par[x]) return x;
    return par[x] = find(par[x]);  // 根を張り替えながら再帰的に根ノードを探す
  }

  // 2つのデータx, yが属する木をマージする
  void unite(int x, int y) {
    // データの根ノードを得る
    x = find(x);
    y = find(y);

    // 既に同じ木に属しているならマージしない
    if (x == y) return;

    // xの木がyの木より大きくなるようにする
    if (sizes[x] < sizes[y]) swap(x, y);

    // xがyの親になるように連結する
    par[y] = x;
    sizes[x] += sizes[y];
    // sizes[y] = 0;  // sizes[y]は無意味な値となるので0を入れておいてもよい
  }

  // 2つのデータx, yが属する木が同じならtrueを返す
  bool same(int x, int y) {
    return find(x) == find(y);
  }

  // データxが含まれる木の大きさを返す
  int size(int x) {
    return sizes[find(x)];
  }
};

int main(){
	ll N;
	cin >> N;
	vector<double> X(N);
	vector<double> Y(N);
	rep(i, N) cin >> X[i] >> Y[i];


	double ok = 0;
	double ng = 200;
	while(ok + 0.00000001 < ng) {
		double mid = (ok + ng)/2.0;

		UnionFind uf(200);
		rep(i, N) if(Y[i] + mid >= 100) uf.unite(i, 100); 
		rep(i, N) if(Y[i] - mid <= -100) uf.unite(i, 101);

		rep(i, N) rep(j, N) if( (X[i] - X[j]) * (X[i] - X[j]) + (Y[i] - Y[j]) * (Y[i] - Y[j]) <= mid * mid) uf.unite(i, j);



		if(uf.find(100) == uf.find(101)) {
			ng = mid;
		} else {
			ok = mid;
		}

	}
	printf("%.10f\n", ok/2);


}