#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
  for (int i(0); i < N; i++) scanf("%d", A + i);
}
struct pt {
  double x, y;
  pt operator-(pt r) { return {x - r.x, y - r.y}; }
  pt operator+(pt r) { return {x + r.x, y + r.y}; }
  pt operator*(double a) { return {x * a, y * a}; }
  bool operator<(const pt &r) const {
    return (x + (1e-10) > r.x && x - (1e-10) < r.x) ? y < r.y : x < r.x;
  }
  bool operator==(const pt &r) const {
    return (x + (1e-10) > r.x && x - (1e-10) < r.x) &&
           (y + (1e-10) > r.y && y - (1e-10) < r.y);
  };
  double dst(pt r = {0, 0}) {
    return sqrt((x - r.x) * (x - r.x) + (y - r.y) * (y - r.y));
  }
  double XP(pt b) { return x * b.y - y * b.x; }
  double DT(pt &b) { return x * b.x + y * b.y; }
  bool gt() { return ~scanf("%lf%lf", &x, &y); }
  void prt() { printf("%.3lf %.3lf\n", x, y); }
} p[(2048)], P = {0, 0};
double XX(pt &a, pt &b, pt &c) {
  return (a.x - c.x) * (b.y - c.y) - (b.x - c.x) * (a.y - c.y);
}
bool cp(pt a, pt b) {
  return (a.y + (1e-10) > b.y && a.y - (1e-10) < b.y) ? a.x < b.x : a.y < b.y;
}
int N, A, B, S;
double T;
int main(void) {
  scanf("%d", &N);
  for (int i(0); i < N; i++) p[i].gt();
  for (int i(0); i < N; i++) P = P + p[i];
  T = P.y / N;
  printf("%.3lf\n", T + 5);
  return 0;
}

### Prompt

Develop a solution in Cpp to the problem described below:



Input

The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of points on a plane.

Each of the next n lines contains two real coordinates xi and yi of the <image> point, specified with exactly 2 fractional digits. All coordinates are between  - 1000 and 1000, inclusive.

Output

Output a single real number θ — the answer to the problem statement. The absolute or relative error of your answer should be at most 10 - 2.

Examples

Input

8
-2.14 2.06
-1.14 2.04
-2.16 1.46
-2.14 0.70
-1.42 0.40
-0.94 -0.48
-1.42 -1.28
-2.16 -1.62


Output

5.410


Input

5
2.26 1.44
2.28 0.64
2.30 -0.30
1.58 0.66
3.24 0.66


Output

5.620


Input

8
6.98 2.06
6.40 1.12
5.98 0.24
5.54 -0.60
7.16 0.30
7.82 1.24
8.34 0.24
8.74 -0.76


Output

5.480


Input

5
10.44 2.06
10.90 0.80
11.48 -0.48
12.06 0.76
12.54 2.06


Output

6.040


Input

8
16.94 2.42
15.72 2.38
14.82 1.58
14.88 0.50
15.76 -0.16
16.86 -0.20
17.00 0.88
16.40 0.92


Output

6.040


Input

7
20.62 3.00
21.06 2.28
21.56 1.36
21.66 0.56
21.64 -0.52
22.14 2.32
22.62 3.04


Output

6.720

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
  for (int i(0); i < N; i++) scanf("%d", A + i);
}
struct pt {
  double x, y;
  pt operator-(pt r) { return {x - r.x, y - r.y}; }
  pt operator+(pt r) { return {x + r.x, y + r.y}; }
  pt operator*(double a) { return {x * a, y * a}; }
  bool operator<(const pt &r) const {
    return (x + (1e-10) > r.x && x - (1e-10) < r.x) ? y < r.y : x < r.x;
  }
  bool operator==(const pt &r) const {
    return (x + (1e-10) > r.x && x - (1e-10) < r.x) &&
           (y + (1e-10) > r.y && y - (1e-10) < r.y);
  };
  double dst(pt r = {0, 0}) {
    return sqrt((x - r.x) * (x - r.x) + (y - r.y) * (y - r.y));
  }
  double XP(pt b) { return x * b.y - y * b.x; }
  double DT(pt &b) { return x * b.x + y * b.y; }
  bool gt() { return ~scanf("%lf%lf", &x, &y); }
  void prt() { printf("%.3lf %.3lf\n", x, y); }
} p[(2048)], P = {0, 0};
double XX(pt &a, pt &b, pt &c) {
  return (a.x - c.x) * (b.y - c.y) - (b.x - c.x) * (a.y - c.y);
}
bool cp(pt a, pt b) {
  return (a.y + (1e-10) > b.y && a.y - (1e-10) < b.y) ? a.x < b.x : a.y < b.y;
}
int N, A, B, S;
double T;
int main(void) {
  scanf("%d", &N);
  for (int i(0); i < N; i++) p[i].gt();
  for (int i(0); i < N; i++) P = P + p[i];
  T = P.y / N;
  printf("%.3lf\n", T + 5);
  return 0;
}

```