#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=j; i<=k; i++)
#define MAXN 500
using namespace std;

typedef double NUM;

const NUM EPS = 1e-12;
const NUM INF = 1e300;

inline NUM sqr(NUM a){
	return a*a;
}

inline NUM cmp(NUM a, NUM b){
	return fabs(a-b)>=EPS+fabs(a)*EPS?a-b:0;
}

struct VEC{
	NUM x,y;
	int tab;
};

inline NUM sqr(const VEC &a){
	return sqr(a.x) + sqr(a.y);
}

inline NUM abs(const VEC &a){
	return sqrt(sqr(a));
}

inline NUM cmp(const VEC &a, const VEC &b){
	NUM at = cmp(a.x, b.x);
	return !at?cmp(a.y,b.y):at;
}

inline VEC operator +(const VEC &a, const VEC &b){
	return (VEC){
		a.x+b.x, a.y+b.y, a.tab
	};
}

inline VEC operator -(const VEC &a, const VEC &b){
	return (VEC){
		a.x-b.x, a.y-b.y, a.tab
	};
}

inline NUM operator *(const VEC &a, const VEC &b){
	return a.x*b.y - a.y*b.x;
}

inline NUM operator %(const VEC &a, const VEC &b){
	return a.x*b.x+a.y*b.y;
}

inline VEC operator ~(const VEC &a){
	return (VEC){
		-a.y, +a.x, a.tab
	};
}

inline VEC operator *(NUM u, const VEC &a){
	return (VEC){
		u * a.x, u* a.y, a.tab
	};
}

inline VEC operator *(const VEC &a, NUM u){
	return (VEC){
		u * a.x, u* a.y, a.tab
	};
}

inline VEC operator /(const VEC &a, NUM u){
	return (VEC){
		a.x / u, a.y / u, a.tab
	};
}

inline VEC operator /(const VEC &a,const VEC &b){
	return a%b/sqr(b)*b;
}

VEC resize(const VEC &a, NUM u){
	return u/abs(a)*a;
}

VEC rotate(const VEC &a, NUM u){
	return (VEC){
		cos(u)*a.x - sin(u) * a.y, sin(u) * a.x + cos(u) * a.y, 0
	};
}

double d[MAXN][MAXN];

int main(){
	int n;
	double r = 100.0;
	VEC des,sta;
	VEC c[10];
	VEC a[1000];
	while(scanf("%d%lf%lf", &n, &des.x, &des.y)!=EOF){
	sta.x = sta.y = 0;
	sta.tab = n + 1;
	des.tab = n + 2;
	rep(i,1,n){
		scanf("%lf%lf", &c[i].x, &c[i].y);
		c[i].tab = i;
	}
	int tot = 1;
	a[tot] = sta;
	rep(i,1,n){
		VEC tmp = sta - c[i];
		double d = abs(tmp);
		double cs = r / d;
		if (d < r)
			continue;
		double sn = sqrt(1 - sqr(cs));
		a[++tot] = c[i] + resize((VEC){tmp.x * cs - tmp.y * sn, tmp.x * sn + tmp.y * cs, i}, r);
		a[++tot] = c[i] + resize((VEC){tmp.x * cs + tmp.y * sn, tmp.y * cs - tmp.x * sn, i}, r);
	}
	rep(i,1,n){
		VEC tmp = des - c[i];
		double d = abs(tmp);
		double cs = r / d;
		if (d < r)
			continue;
		double sn = sqrt(1 - sqr(cs));
		a[++tot] = c[i] + resize((VEC){tmp.x * cs - tmp.y * sn, tmp.x * sn + tmp.y * cs, i}, r);
		a[++tot] = c[i] + resize((VEC){tmp.x * cs + tmp.y * sn, tmp.y * cs - tmp.x * sn, i}, r);
		
	}
	rep(i,1,n)
		rep(j,i+1,n){
			VEC tmp = c[i] - c[j];
			VEC hor = resize(~tmp, r);
			a[++tot] = c[i] + hor;
			a[++tot] = c[i] - hor;
			a[++tot] = c[j] + hor;
			a[++tot] = c[j] - hor;
			double d = abs(tmp);
			double cs = 2 * r / d;
			if (cs <= 1){
				double sn = sqrt(1 - sqr(cs));
				a[++tot] = c[j] + resize((VEC){tmp.x * cs - tmp.y * sn, tmp.x * sn + tmp.y * cs, j}, r);
				a[++tot] = c[j] + resize((VEC){tmp.x * cs + tmp.y * sn, tmp.y * cs - tmp.x * sn, j}, r);
				a[++tot] = c[i] - resize((VEC){tmp.x * cs - tmp.y * sn, tmp.x * sn + tmp.y * cs, i}, r);
				a[++tot] = c[i] - resize((VEC){tmp.x * cs + tmp.y * sn, tmp.y * cs - tmp.x * sn, i}, r);
			}
		}
	a[++tot] = des;
	rep(i,1,tot)
		rep(j,1,tot)
			if (i == j)
				d[i][j] = 0;
			else
			if (a[i].tab != a[j].tab){
				int flag = 1;
				rep(k,1,n){
					VEC tmp = a[i] + (c[k] - a[i]) / (a[j] - a[i]);
					NUM at = cmp(r * r, sqr(tmp - c[k]));
					if (at <= 0) 
						continue;
					VEC tmp2 = resize(a[j] - a[i], sqrt(at));
					if (((tmp + tmp2 - a[i]) % (tmp + tmp2 - a[j]) < 0)||((tmp - tmp2 - a[i]) % (tmp - tmp2 - a[j]) < 0)){
						flag = 0;
						break;
					}
				}
				if (flag)
					d[i][j] = abs(a[i] - a[j]);
				else
					d[i][j] = INF;
			}
			else{
				int l = a[i].tab;
				int good = 1, bad = 1;
				rep(k,1,n){
					if ((k != l) && (abs(c[k] - c[l]) <= 2*r)){
						if ((((a[i] - c[l]) * (c[k] - c[l])) * ((a[j] - c[l]) * (c[k] - c[l])) < 0)&&(((c[l] - a[i]) * (a[j] - a[i])) * ((c[k] - a[i]) * (a[j] - a[i])) < 0))
							bad = 0;
						else{
							if ((((a[i] - c[l]) * (c[k] - c[l])) * ((a[j] - c[l]) * (c[k] - c[l])) <= 0)&&(((c[l] - a[i]) * (a[j] - a[i])) * ((c[k] - a[i]) * (a[j] - a[i])) <= 0)){
								if ((a[i] - c[l]) * (c[k] - c[l]) < 0)
									bad = 0;
								else
									good = 0;
							}
							else{
								good = 0;
							}
						}
					}
				}
				double sita = acos(((a[i] - c[l]) % (a[j] - c[l])) / abs(a[i] - c[l]) / abs(a[j] - c[l]));
				if (bad)
					d[i][j] = r * sita;
				else
					if (good)
						d[i][j] = r * (2 * acos(-1) - sita);
					else
						d[i][j] = INF;
			}
	rep(i,1,tot){
		rep(k,1,n)
			if (abs(a[i]-c[k])<r-0.001){
				rep(j,1,tot)
					d[i][j] = d[j][i] = INF;
			}
	}
	rep(k,1,tot)
		rep(i,1,tot)
			rep(j,1,tot)
				d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
	if (d[1][tot] >= INF / 2)
		printf("0.0\n");
	else
		printf("%.5lf\n", d[1][tot]);
	}
}