#include <bits/stdc++.h>
template <class T>
inline T sqr(T x) {
  return x * x;
}
#pragma comment(linker, "/STACK:64000000")
using namespace std;
using namespace std;
struct point {
  int x, y, ind;
};
bool is_rect(vector<point> p) {
  return ((p[1].x - p[0].x) * (p[2].x - p[1].x) +
                  (p[1].y - p[0].y) * (p[2].y - p[1].y) ==
              0 &&
          (p[2].x - p[1].x) * (p[3].x - p[2].x) +
                  (p[2].y - p[1].y) * (p[3].y - p[2].y) ==
              0 &&
          (p[3].x - p[2].x) * (p[0].x - p[3].x) +
                  (p[3].y - p[2].y) * (p[0].y - p[3].y) ==
              0 &&
          (p[0].x - p[3].x) * (p[1].x - p[0].x) +
                  (p[0].y - p[3].y) * (p[1].y - p[0].y) ==
              0);
}
bool is_q(vector<point> p) {
  return (sqr(p[0].x - p[1].x) + sqr(p[0].y - p[1].y) ==
              sqr(p[1].x - p[2].x) + sqr(p[1].y - p[2].y) &&
          sqr(p[1].x - p[2].x) + sqr(p[1].y - p[2].y) ==
              sqr(p[2].x - p[3].x) + sqr(p[2].y - p[3].y) &&
          sqr(p[2].x - p[3].x) + sqr(p[2].y - p[3].y) ==
              sqr(p[3].x - p[0].x) + sqr(p[3].y - p[0].y));
}
void wr(vector<point> p1, vector<point> p2) {
  cout << "YES" << endl;
  for (int i = 0; i < 4; ++i) cout << p1[i].ind << " ";
  cout << endl;
  for (int i = 0; i < 4; ++i) cout << p2[i].ind << " ";
}
bool comper(point l, point r) {
  if (l.x == r.x) return l.y < r.y;
  return l.x < r.x;
}
int main() {
  point p[8];
  for (int i = 0; i < 8; ++i) {
    scanf("%d %d", &p[i].x, &p[i].y);
    p[i].ind = i + 1;
  }
  int a[8];
  memset(a, 0, sizeof a);
  for (int i = 0; i < (1 << 8) + 1; ++i) {
    for (int j = 0; j < 8; ++j) {
      if (a[j]) {
        a[j] = 0;
        continue;
      }
      a[j] = 1;
      break;
    }
    int q = 0;
    vector<point> sol(4), sol1(4);
    for (int j = 0; j < 8; ++j)
      if (a[j]) {
        if (q == 4) {
          q++;
          break;
        }
        sol[q++] = p[j];
      }
    if (q != 4) continue;
    q = 0;
    for (int j = 0; j < 8; ++j)
      if (!a[j]) sol1[q++] = p[j];
    sort(sol.begin(), sol.end(), comper);
    sort(sol1.begin(), sol1.end(), comper);
    if ((sol[1].x - sol[0].x) * (sol[3].y - sol[1].y) -
            (sol[1].y - sol[0].y) * (sol[3].x - sol[1].x) >
        0)
      swap(sol[1], sol[2]);
    if ((sol1[1].x - sol1[0].x) * (sol1[3].y - sol1[1].y) -
            (sol1[1].y - sol1[0].y) * (sol1[3].x - sol1[1].x) >
        0)
      swap(sol1[1], sol1[2]);
    swap(sol[3], sol[2]);
    swap(sol1[3], sol1[2]);
    if (is_rect(sol) && is_rect(sol1)) {
      if (is_q(sol)) {
        wr(sol, sol1);
        return 0;
      }
      if (is_q(sol1)) {
        wr(sol1, sol);
        return 0;
      }
    }
  }
  cout << "NO";
  return 0;
}
