Problem: Tom loves vowels, and he likes long words with many vowels. His favorite words are vowelly words. We say a word of length k is vowelly if there are positive integers n and m such that n⋅ m = k and when the word is written by using n rows and m columns (the first row is filled first, then the second and so on, with each row filled from left to right), every vowel of the English alphabet appears at least once in every row and every column.

You are given an integer k and you must either print a vowelly word of length k or print -1 if no such word exists.

In this problem the vowels of the English alphabet are 'a', 'e', 'i', 'o' ,'u'.

Input

Input consists of a single line containing the integer k (1≤ k ≤ 10^4) — the required length.

Output

The output must consist of a single line, consisting of a vowelly word of length k consisting of lowercase English letters if it exists or -1 if it does not.

If there are multiple possible words, you may output any of them.

Examples

Input


7


Output


-1


Input


36


Output


agoeuioaeiruuimaeoieauoweouoiaouimae

Note

In the second example, the word "agoeuioaeiruuimaeoieauoweouoiaouimae" can be arranged into the following 6 × 6 grid:

<image>

It is easy to verify that every row and every column contain all the vowels.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
inline void read(int &a);
const int maxn = 1e5 + 10;
const int N = 3e5 + 10;
const int inf = 0x3f3f3f3f;
const int mnf = 0x1f1f1f1f;
const double eps = 1e-6;
const double pi = acos(-1.0);
int sgn(double a) { return a < -eps ? -1 : a > eps; }
int cmppoint(double a, double b) { return sgn(a - b); }
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
struct ball {
  double x, y, z, r;
};
double balldis(ball a, ball b) {
  double ans = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) +
                    (a.z - b.z) * (a.z - b.z));
  return ans;
}
double ar3(ball a) {
  double ans = (4.0 / 3) * pi * a.r * a.r * a.r;
  return ans;
}
double Uball(ball a, ball b) {
  double ans = 0;
  double d = balldis(a, b);
  if (sgn(d - a.r - b.r) >= 0) {
    ans = ar3(a) + ar3(b);
  } else if (d <= abs(a.r - b.r)) {
    ans = max(ar3(a), ar3(b));
  } else {
    double c = (a.r * a.r + d * d - b.r * b.r) / (2.0 * d * a.r);
    double h = a.r * (1 - c);
    ans += (1.0 / 3) * pi * (3 * a.r - h) * h * h;
    c = (b.r * b.r + d * d - a.r * a.r) / (2.0 * d * b.r);
    h = b.r * (1 - c);
    ans += (1.0 / 3) * pi * (3 * b.r - h) * h * h;
    ans = ar3(a) + ar3(b) - ans;
  }
  return ans;
}
struct point {
  double x, y;
  point() {}
  point(double _x, double _y) {
    x = _x;
    y = _y;
  }
  double len2() { return x * x + y * y; }
  point operator-(const point &b) const { return point(x - b.x, y - b.y); }
  point operator+(const point &b) const { return point(x + b.x, y + b.y); }
  double operator^(const point &b) const { return x * b.y - y * b.x; }
  double operator*(const point &b) const { return x * b.x + y * b.y; }
  point operator/(const double &k) const { return point(x / k, y / k); }
  point operator*(const double &k) const { return point(x * k, y * k); }
  bool operator<(point p) const {
    int c = cmppoint(x, p.x);
    if (c) return c == -1;
    return cmppoint(y, p.y) == -1;
  }
  bool operator==(point o) const {
    return cmppoint(x, o.x) == 0 && cmppoint(y, o.y) == 0;
  }
  point rotleft() { return point(-y, x); }
  point rotright() { return point(y, -x); }
  point rotate(point p, double angle) {
    point v = (*this) - p;
    double c = cos(angle), s = sin(angle);
    return point(p.x + v.x * c - v.y * s, p.y + v.x * s + v.y * c);
  }
  double rad(point a, point b) {
    point p = *this;
    return fabs(atan2(fabs((a - p) ^ (b - p)), (a - p) * (b - p)));
  }
  point trunc(double r) {
    double l = hypot(x, y);
    if (sgn(l)) return *this;
    r /= l;
    return point(x * r, y * r);
  }
  void input() { scanf("%lf%lf", &x, &y); }
};
double dist(point a, point b) { return sqrt((a - b) * (a - b)); }
struct line {
  point s, e;
  line() {}
  line(point _s, point _e) {
    s = _s;
    e = _e;
  }
  bool operator==(line v) { return (s == v.s) && (e == v.e); }
  line(point p, double angle) {
    s = p;
    if (sgn(angle - pi / 2) == 0)
      e = (s + point(0, 1));
    else
      e = (s + point(1, tan(angle)));
  }
  line(double a, double b, double c) {
    if (sgn(a) == 0) {
      s = point(0, -c / b);
      e = point(1, -c / b);
    } else if (sgn(b) == 0) {
      s = point(-c / a, 0);
      e = point(-c / a, 1);
    } else {
      s = point(0, -c / b);
      e = point(1, (-c - a) / b);
    }
  }
  void input() {
    s.input();
    e.input();
  }
  void adjust() {
    if (e < s) swap(e, s);
  }
  double length() { return dist(e, s); }
  double angle() {
    double k = atan2(e.y - s.y, e.x - s.x);
    if (sgn(k) < 0) k += pi;
    if (sgn(k - pi) == 0) k -= pi;
    return k;
  }
  int relation(point p) {
    int c = sgn((p - s) ^ (e - s));
    if (c < 0)
      return 1;
    else if (c > 0)
      return 2;
    else
      return 3;
  }
  bool pointonseg(point p) {
    return sgn((p - s) ^ (e - s)) == 0 && sgn((p - s) * (p - e)) <= 0;
  }
  int segtoseg(line v) {
    int d1 = sgn((e - s) ^ (v.s - s));
    int d2 = sgn((e - s) ^ (v.e - s));
    int d3 = sgn((v.e - v.s) ^ (s - v.s));
    int d4 = sgn((v.e - v.s) ^ (e - v.s));
    if ((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2;
    return (d1 == 0 && sgn((v.s - s) * (v.s - e)) <= 0) ||
           (d2 == 0 && sgn((v.e - s) * (v.e - e)) <= 0) ||
           (d3 == 0 && sgn((s - v.s) * (s - v.e)) <= 0) ||
           (d4 == 0 && sgn((e - v.s) * (e - v.e)) <= 0);
  }
  double dispointtoline(point p) { return ((p - s) ^ (e - s)) / dist(s, e); }
  double dispointtoseg(point p) {
    if (sgn((p - s) * (e - s)) < 0 || sgn((p - e) * (s - e)) < 0)
      return min(dist(p, s), dist(p, e));
    return fabs(dispointtoline(p));
  }
  double dissegtoseg(line v) {
    return min(min(dispointtoseg(v.s), dispointtoseg(v.e)),
               min(v.dispointtoseg(s), v.dispointtoseg(e)));
  }
  point lineprog(point p) {
    return s + (((e - s) * ((e - s) * (p - s))) / ((e - s).len2()));
  }
  point symmetrypoint(point p) {
    point q = lineprog(p);
    return point(2 * q.x - p.x, 2 * q.y - p.y);
  }
  int linetoseg(line v) {
    int d1 = sgn((e - s) ^ (v.s - s));
    int d2 = sgn((e - s) ^ (v.e - s));
    if ((d1 ^ d2) == -2) return 2;
    return (d1 == 0 || d2 == 0);
  }
  bool operator<(line &l) const {
    if (e.x == l.e.x) return s.x < l.s.x;
    return e.x < l.e.x;
  }
  pair<int, point> operator&(const line &b) const {
    point res = s;
    if (sgn((s - e) ^ (b.s - b.e)) == 0) {
      if (sgn((s - b.e) ^ (b.s - b.e)) == 0)
        return make_pair(0, res);
      else
        return make_pair(1, res);
    }
    double t = ((s - b.s) ^ (b.s - b.e)) / ((s - e) ^ (b.s - b.e));
    res.x += (e.x - s.x) * t;
    res.y += (e.y - s.y) * t;
    return make_pair(2, res);
  }
};
struct triangle {
  point v[3];
  double ar2() {
    return fabs(0.5 * ((v[1].x - v[0].x) * (v[2].y - v[0].y) -
                       (v[2].x - v[0].x) * (v[1].y - v[0].y)));
  }
};
struct circle {
  point center;
  double r;
  circle() {}
  circle(point p, double _r) {
    center = p;
    r = _r;
  }
  circle(double x, double y, double _r) {
    center = point(x, y);
    r = _r;
  }
  void input() {
    center.input();
    cin >> r;
  }
  bool operator==(circle v) {
    return (center == v.center) && sgn(r - v.r) == 0;
  }
  bool operator<(circle v) const {
    return ((center < v.center) || ((center == v.center) && sgn(r - v.r) < 0));
  }
  void outtriangle(point a, point b, point c) {
    line u = line((a + b) / 2, ((a + b) / 2) + ((b - a).rotleft()));
    line v = line((b + c) / 2, ((b + c) / 2) + ((c - b).rotleft()));
    pair<int, point> p = u & v;
    center = p.second;
    r = dist(center, a);
  }
  void intriangle(point a, point b, point c) {
    line u, v;
    double m = atan2(b.y - a.y, b.x - a.x), n = atan2(c.y - a.y, c.x - a.x);
    u.s = a;
    u.e = u.s + point(cos((m + n) / 2), sin((m + n) / 2));
    v.s = b;
    v.e = v.s + point(cos((m + n) / 2), sin((m + n) / 2));
    pair<int, point> p = u & v;
    center = p.second;
    r = line(a, b).dispointtoseg(center);
  }
  double area() { return pi * r * r; }
  double circumference() { return 2 * pi * r; }
  int relationtopoint(point b) {
    double dst = dist(b, center);
    if (sgn(dst - r) < 0)
      return 2;
    else if (sgn(dst - r) == 0)
      return 0;
    return 0;
  }
  int relationtoseg(line v) {
    double dst = v.dispointtoseg(center);
    if (sgn(dst - r) < 0)
      return 2;
    else if (sgn(dst - r) == 0)
      return 1;
    return 0;
  }
  int relationtoline(line v) {
    double dst = v.dispointtoline(center);
    if (sgn(dst - r) < 0) return 2;
    if (sgn(dst - r) == 0) return 1;
    return 0;
  }
  int relationtocircle(circle v) {
    double d = dist(center, v.center);
    if (sgn(d - r - v.r) > 0) return 5;
    if (sgn(d - r - v.r) == 0) return 4;
    double l = fabs(r - v.r);
    if (sgn(d - r - v.r) < 0 && sgn(d - l) > 0) return 3;
    if (sgn(d - l) == 0) return 2;
    if (sgn(d - l) < 0) return 1;
  }
  int circle_inter(circle v, point &p1, point &p2) {
    int rel = relationtocircle(v);
    if (rel == 1 || rel == 5) return 0;
    double d = dist(center, v.center);
    double l = (d * d + r * r - v.r * v.r) / (2 * d);
    double h = sqrt(r * r - l * l);
    point tmp = center + (v.center - center).trunc(l);
    p1 = tmp + ((v.center - center).rotleft().trunc(h));
    p2 = tmp + ((v.center - center).rotright().trunc(h));
    if (rel == 2 || rel == 4) return 1;
    return 2;
  }
  int circle_line(line v, point &p1, point &p2) {
    if (!(*this).relationtoline(v)) return 0;
    point a = v.lineprog(center);
    double d = v.dispointtoline(center);
    d = sqrt(r * r - d * d);
    if (sgn(d) == 0) {
      p1 = a;
      p2 = a;
      return 1;
    }
    p1 = a + (v.e - v.s).trunc(d);
    p2 = a - (v.e - v.s).trunc(d);
    return 2;
  }
  int getcircle(point a, point b, double r1, circle &c1, circle &c2) {
    circle x(a, r1), y(b, r1);
    int t = x.circle_inter(y, c1.center, c2.center);
    if (!t) return 0;
    c1.r = c2.r = r1;
    return t;
  }
  int getcircle(line u, point q, double r1, circle &c1, circle &c2) {
    double dis = u.dispointtoline(q);
    if (sgn(dis - 2 * r1) > 0) return 0;
    if (sgn(dis) == 0) {
      c1.center = q + ((u.e - u.s).rotleft().trunc(r1));
      c2.center = q + ((u.e - u.s).rotright().trunc(r1));
      c1.r = c2.r = r1;
      return 2;
    }
    line u1 = line((u.s + (u.e - u.s).rotleft().trunc(r1)),
                   (u.e + (u.e - u.s).rotleft().trunc(r1)));
    line u2 = line((u.s + (u.e - u.s).rotright().trunc(r1)),
                   (u.e + (u.e - u.s).rotright().trunc(r1)));
    circle cc = circle(q, r1);
    point p1, p2;
    if (!cc.circle_line(u1, p1, p2)) cc.circle_line(u2, p1, p2);
    c1 = circle(p1, r1);
    if (p1 == p2) {
      c2 = c1;
      return 1;
    }
    c2 = circle(p2, r1);
    return 2;
  }
  int getcircle(line u, line v, double r1, circle &c1, circle &c2, circle &c3,
                circle &c4) {
    pair<int, point> pp = u & v;
    if (pp.first < 2) return 0;
    line u1 = line(u.s + (u.e - u.s).rotleft().trunc(r1),
                   u.e + (u.e - u.s).rotleft().trunc(r1));
    line u2 = line(u.s + (u.e - u.s).rotright().trunc(r1),
                   u.e + (u.e - u.s).rotright().trunc(r1));
    line v1 = line(v.s + (v.e - v.s).rotleft().trunc(r1),
                   v.e + (v.e - v.s).rotleft().trunc(r1));
    line v2 = line(v.s + (v.e - v.s).rotright().trunc(r1),
                   v.e + (v.e - v.s).rotright().trunc(r1));
    c1.r = c2.r = c3.r = c4.r = r1;
    pp = u1 & v1;
    c1.center = pp.second;
    pp = u1 & v2;
    c2.center = pp.second;
    pp = u2 & v1;
    c3.center = pp.second;
    pp = u2 & v2;
    c4.center = pp.second;
    return 4;
  }
  int get(circle cx, circle cy, double r1, circle &c1, circle &c2) {
    circle x(cx.center, r1 + cx.r), y(cy.center, cy.r + r1);
    int t = x.circle_inter(y, c1.center, c2.center);
    if (!t) return 0;
    c1.r = c2.r = r1;
    return t;
  }
  int tangentline(point q, line &u, line &v) {
    int x = relationtopoint(q);
    if (x == 2) return 0;
    if (x == 1) {
      u = line(q, q + (q - center).rotleft());
      v = u;
      return 1;
    }
    double d = dist(q, center);
    double l = r * r / d;
    double h = sqrt(r * r - l * l);
    u = line(
        q, center + ((q - center).trunc(l) + (q - center).rotleft().trunc(h)));
    v = line(
        q, center + ((q - center).trunc(l) + (q - center).rotright().trunc(h)));
    return 2;
  }
  double area_circle(circle v) {
    int rel = relationtocircle(v);
    if (rel >= 4) return 0.0;
    if (rel <= 2) return min(area(), v.area());
    double d = dist(center, v.center);
    double hf = (r + v.r + d) / 2.0;
    double ss = 2 * sqrt(hf * (hf - r) * (hf - v.r) * (hf - d));
    double a1 = acos((r * r + d * d - v.r * v.r) / (2.0 * r * d));
    a1 = a1 * r * r;
    double a2 = acos((v.r * v.r + d * d - r * r) / (2.0 * v.r * d));
    a2 = a2 * r * r;
    return a1 + a2 - ss;
  }
  double area_triangle(point a, point b) {
    if (sgn((center - a) ^ (center - b)) == 0) return 0.0;
    point q[5];
    int len = 0;
    q[len++] = a;
    line l(a, b);
    point p1, p2;
    if (circle_line(l, q[1], q[2]) == 2) {
      if (sgn((a - q[1]) * (b - q[1]) < 0)) q[len++] = q[1];
      if (sgn((a - q[2]) * (b - q[2]) < 0)) q[len++] = q[2];
    }
    q[len++] = b;
    if (len == 4 && sgn((q[0] - q[1]) * (q[2] - q[1])) > 0) swap(q[1], q[2]);
    double res = 0;
    for (int i = 0; i < len - 1; i++) {
      if (relationtopoint(q[i]) == 0 || relationtopoint(q[i + 1]) == 0) {
        double arg = center.rad(q[i], q[i + 1]);
        res += r * r * arg / 2.0;
      } else
        res += fabs((q[i] - center) ^ (q[i + 1] - center)) / 2.0;
    }
    return res;
  }
};
struct polygon {
  int n;
  point p[maxn];
  line l[maxn];
  void input(int _n) {
    n = _n;
    for (int i = 0; i < n; i++) p[i].input();
  }
  void add(point q) { p[n++] = q; }
  void getline() {
    for (int i = 0; i < n; i++) l[i] = line(p[i], p[(i + 1) % n]);
  }
  struct cmp {
    point p;
    cmp(const point &p0) { p = p0; }
    bool operator()(const point &aa, const point &bb) {
      point a = aa, b = bb;
      int d = sgn((a - p) ^ (b - p));
      if (d == 0) return sgn(dist(a, p) - dist(b, p)) < 0;
      return 0;
    }
  };
  void norm() {
    point mi = p[0];
    for (int i = 1; i < n; i++) mi = min(mi, p[i]);
    sort(p, p + n, cmp(mi));
  }
  void getconvex(polygon &convex) {
    sort(p, p + n);
    convex.n = n;
    for (int i = 0; i < min(n, 2); i++) convex.p[i] = p[i];
    if (convex.n == 2 && (convex.p[0] == convex.p[1])) convex.n--;
    if (n <= 2) return;
    int &top = convex.n;
    top = 1;
    for (int i = 2; i < n; i++) {
      while (top &&
             sgn((convex.p[top] - p[i]) ^ (convex.p[top - 1] - p[i])) <= 0)
        top--;
      convex.p[++top] = p[i];
    }
    if (convex.n == 2 && (convex.p[0] == convex.p[1])) convex.n--;
    convex.norm();
  }
  bool isconvex() {
    bool s[2];
    memset(s, false, sizeof(s));
    for (int i = 0; i < n; i++) {
      int j = (i + 1) % n;
      int k = (j + 1) % n;
      s[sgn((p[j] - p[i]) ^ (p[k] - p[i])) + 1] = true;
      if (s[0] == s[2]) return false;
    }
    return true;
  }
  int relationpoint(point q) {
    for (int i = 0; i < n; i++)
      if (p[i] == q) return 3;
    getline();
    for (int i = 0; i < n; i++)
      if (l[i].pointonseg(q)) return 2;
    int cnt = 0;
    for (int i = 0; i < n; i++) {
      int j = (i + 1) % n;
      int k = sgn((q - p[j]) ^ (p[i] - p[j]));
      int u = sgn(p[i].y - q.y);
      int v = sgn(p[j].y - q.y);
      if (k > 0 && u < 0 && v >= 0) cnt++;
      if (k < 0 && u < 0 && v >= 0) cnt--;
    }
    return cnt != 0;
  }
  void convexcut(line u, polygon &po) {
    int &top = po.n;
    top = 0;
    for (int i = 0; i < n; i++) {
      int d1 = sgn((u.e - u.s) ^ (p[i] - u.s));
      int d2 = sgn((u.e - u.s) ^ (p[(i + 1) % n] - u.s));
      if (d1 >= 0) po.p[top++] = p[i];
      pair<int, point> pr = u & line(p[i], p[(i + 1) % n]);
      if (d1 * d2 < 0) po.p[top++] = pr.second;
    }
  }
  double getcircumference() {
    double sum = 0;
    for (int i = 0; i < n; i++) sum += dist(p[i], p[(i + 1) % n]);
    return sum;
  }
  double getarea() {
    double sum = 0;
    for (int i = 0; i < n; i++) sum += (p[i] ^ p[(i + 1) % n]);
    return fabs(sum) / 2.0;
  }
  bool getdir() {
    double sum = 0;
    for (int i = 0; i < n; i++) sum += (p[i] ^ p[(i + 1) % n]);
    if (sgn(sum) > 0) return 1;
    return 0;
  }
  point getbarycenter() {
    point ret(0, 0);
    double area = 0;
    for (int i = 1; i < n - 1; i++) {
      double tmp = (p[i] - p[0]) ^ (p[i + 1] - p[0]);
      if (sgn(tmp) == 0) continue;
      area += tmp;
      ret.x += (p[0].x + p[i].x + p[i + 1].x) / 3 * tmp;
      ret.y += (p[0].y + p[i].y + p[i + 1].y) / 3 * tmp;
    }
    if (sgn(area)) ret = ret / area;
    return ret;
  }
  double area_circle(circle c) {
    double ans = 0;
    for (int i = 0; i < n; i++) {
      int j = (i + 1) % n;
      if (sgn((p[j] - c.center) ^ (p[i] - c.center)) >= 0)
        ans += c.area_triangle(p[i], p[j]);
      else
        ans -= c.area_triangle(p[i], p[j]);
    }
    return fabs(ans);
  }
  int relationcircle(circle c) {
    getline();
    int x = 2;
    if (relationpoint(c.center) != 1) return 0;
    for (int i = 0; i < n; i++) {
      if (c.relationtoseg(l[i]) == 2) return 0;
      if (c.relationtoseg(l[i]) == 1) x = 1;
    }
    return x;
  }
};
bool OnSeg(point P, line L);
circle CroCircle(int n);
pair<ball, ball> lineToBall(ball par, ball bp, ball sp);
ball CroBall(int n);
int cmpgra(point a, point b);
int graham(int n);
point p[maxn], s[maxn];
ball bl[maxn];
int prime[maxn];
void isprime() {
  memset(prime, 0, sizeof(prime));
  for (int i = 2; i <= maxn; i++) {
    if (!prime[i]) prime[++prime[0]] = i;
    for (int j = 1; j <= prime[0] && prime[j] <= maxn / i; j++) {
      prime[prime[j] * i] = 1;
      if (i % prime[j] == 0) break;
    }
  }
}
int n, m, sx, sy, mp[500][500], vis[500][500];
int dx[8] = {1, 1, 2, 2, -1, -1, -2, -2}, dy[8] = {2, -2, 1, -1, 2, -2, 1, -1};
struct node {
  int x, y;
  int step;
  node(){};
  node(int _x, int _y, int s) { x = _x, y = _y, step = s; }
};
bool check(int x, int y) {
  if (x < 1 || x > n || y < 1 || y > m || vis[x][y]) return false;
  return true;
}
char c[5] = {'a', 'e', 'i', 'o', 'u'};
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int n;
  cin >> n;
  if (n < 25) {
    cout << -1;
    return 0;
  }
  int a = 0, b = 0;
  for (int i = 5; i < (int)(sqrt(0.5 + n) + 1); i++) {
    if (!(n % i) && (n / i) > 4) {
      a = i, b = n / i;
      break;
    }
  }
  if (a == 0 && b == 0) {
    cout << -1;
    return 0;
  }
  int ind = 0;
  for (int i = 0; i < a; i++) {
    ind = i % 5;
    for (int j = 0; j < b; j++) {
      cout << c[(ind + j) % 5];
    }
  }
  cout << '\n';
  return 0;
}
inline void read(int &a) {
  static char c;
  bool flag = false;
  while (((c = getchar()) < '0' || c > '9')) flag = 1;
  a = c - '0';
  while ((c = getchar()) >= '0' && c <= '9') a = (a << 3) + (a << 1) + c - '0';
  if (flag) a = -a;
}
bool OnSeg(point P, line L) {
  return sgn((L.s - P) ^ (L.e - P)) == 0 &&
         sgn((P.x - L.s.x) * (P.x - L.e.x)) <= 0 &&
         sgn((P.y - L.s.y) * (P.y - L.e.y)) <= 0;
}
circle CroCircle(int n) {
  random_shuffle(p + 1, p + n + 1);
  circle tep;
  tep.center = p[1];
  tep.r = 0;
  for (int i = 2; i <= n; i++) {
    if (dist(p[i], tep.center) > tep.r + eps) {
      tep.center = p[i];
      tep.r = 0;
      for (int j = 1; j < i; j++) {
        if (dist(p[j], tep.center) > tep.r + eps) {
          tep.center.x = (p[i].x + p[j].x) / 2;
          tep.center.y = (p[i].y + p[j].y) / 2;
          tep.r = dist(p[i], p[j]) / 2;
          for (int k = 1; k < j; k++) {
            if (dist(p[k], tep.center) > tep.r + eps) {
              triangle t;
              t.v[0] = p[i];
              t.v[1] = p[j];
              t.v[2] = p[k];
              tep.outtriangle(t.v[0], t.v[1], t.v[2]);
            }
          }
        }
      }
    }
  }
  return tep;
}
ball CroBall(int n) {
  double step = 100, mt;
  int s = 0;
  ball z;
  z.x = z.y = z.z = 0;
  z.r = 1e30;
  while (step > eps) {
    for (int i = 1; i <= n; i++)
      if (balldis(z, bl[s]) < balldis(z, bl[i])) s = i;
    mt = balldis(z, bl[s]);
    z.r = min(z.r, mt);
    z.x += (bl[s].x - z.x) / mt * step;
    z.y += (bl[s].y - z.y) / mt * step;
    z.z += (bl[s].z - z.z) / mt * step;
    step *= 0.98;
  }
  return z;
}
pair<ball, ball> lineToBall(ball par, ball bp, ball sp) {
  ball ans1, ans2;
  if (bp.x != sp.x) {
    double k_xy = (sp.y - bp.y) / (sp.x - bp.x);
    double b_xy = bp.y - k_xy * bp.x;
    double k_zx = (sp.z - bp.z) / (sp.x - bp.x);
    double b_zx = bp.z - k_zx * bp.x;
    double A = 1 + k_xy * k_xy + k_zx * k_zx;
    double B =
        2 * k_xy * (b_xy - par.y) + 2 * k_zx * (b_zx - par.z) - 2 * par.x;
    double C = par.x * par.x + (b_xy - par.y) * (b_xy - par.y) +
               (b_zx - par.z) * (b_zx - par.z) - par.r * par.r;
    ans1.x = (-B + sqrt(B * B - 4 * A * C)) / (2 * A);
    ans1.y = k_xy * ans1.x + b_xy;
    ans1.z = k_zx * ans1.x + b_zx;
    ans2.x = (-B - sqrt(B * B - 4 * A * C)) / (2 * A);
    ans2.y = k_xy * ans2.x + b_xy;
    ans2.z = k_zx * ans2.x + b_zx;
  } else {
    if (bp.y != sp.y) {
      double k_zy = (sp.z - bp.z) / (sp.y - bp.y);
      double b_zy = sp.z - k_zy * sp.y;
      double A = 1 + k_zy * k_zy;
      double B = 2 * k_zy * (b_zy - par.z) - 2 * par.y;
      double C = par.y * par.y + (b_zy - par.z) * (b_zy - par.z) -
                 (bp.x - par.x) * (bp.x - par.x) - par.r * par.r;
      ans1.x = bp.x;
      ans1.y = (-B + sqrt(B * B - 4 * A * C)) / (2 * A);
      ans1.z = k_zy * ans1.y + b_zy;
      ans2.x = bp.x;
      ans2.y = (-B - sqrt(B * B - 4 * A * C)) / (2 * A);
      ans2.z = k_zy * ans1.y + b_zy;
    } else {
      if (bp.z != sp.z) {
        ans1.x = bp.x;
        ans1.y = bp.y;
        ans1.z = par.z + sqrt(par.r * par.r - (bp.x - par.x) * (bp.x - par.x) -
                              (bp.y - par.y) * (bp.y * par.y));
        ans2.x = bp.x;
        ans2.y = bp.y;
        ans2.z = par.z - sqrt(par.r * par.r - (bp.x - par.x) * (bp.x - par.x) -
                              (bp.y - par.y) * (bp.y * par.y));
      } else {
        ans1.x = ans2.x = bp.x;
        ans1.y = ans2.y = bp.y;
        ans1.z = ans2.z = bp.z;
      }
    }
  }
  return make_pair(ans1, ans2);
}
int cmpgra(point a, point b) {
  double x =
      ((a.x - p[1].x) * (b.y - p[1].y) - (b.x - p[1].x) * (a.y - p[1].y));
  if (x > 0) return 1;
  if (x == 0 && dist(a, p[1]) < dist(b, p[1])) return 1;
  return 0;
}
int graham(int n) {
  int k = 1;
  for (int i = 2; i <= n; i++)
    if (p[i].y < p[k].y || (p[i].y == p[k].y && p[i].x < p[k].x)) k = i;
  swap(p[1], p[k]);
  sort(p + 2, p + 1 + n, cmpgra);
  s[1] = p[1];
  s[2] = p[2];
  int t = 2;
  for (int i = 3; i <= n; i++) {
    while (t >= 2 && ((s[t].x - s[t - 1].x) * (p[i].y - s[t - 1].y) -
                      (p[i].x - s[t - 1].x) * (s[t].y - s[t - 1].y)) <= 0)
      t--;
    s[++t] = p[i];
  }
  return t;
}