#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


struct Pt {
  Int x, y;
  Pt() {}
  Pt(Int x_, Int y_) : x(x_), y(y_) {}
  Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
  Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
  Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
  Pt operator+() const { return Pt(+x, +y); }
  Pt operator-() const { return Pt(-x, -y); }
  Pt operator*(const Int &k) const { return Pt(x * k, y * k); }
  Pt operator/(const Int &k) const { return Pt(x / k, y / k); }
  friend Pt operator*(const Int &k, const Pt &a) { return Pt(k * a.x, k * a.y); }
  Pt &operator+=(const Pt &a) { x += a.x; y += a.y; return *this; }
  Pt &operator-=(const Pt &a) { x -= a.x; y -= a.y; return *this; }
  Pt &operator*=(const Pt &a) { return *this = *this * a; }
  Pt &operator*=(const Int &k) { x *= k; y *= k; return *this; }
  Int abs2() const { return x * x + y * y; }
  Int dot(const Pt &a) const { return x * a.x + y * a.y; }
  Int det(const Pt &a) const { return x * a.y - y * a.x; }
  bool operator==(const Pt &a) const { return (x == a.x && y == a.y); }
  bool operator<(const Pt &a) const { return (x < a.x || (x == a.x && y < a.y)); }
  friend ostream &operator<<(ostream &os, const Pt &a) { os << "(" << a.x << ", " << a.y << ")"; return os; }
};
int sig(Int r) { return (r < 0) ? -1 : (r > 0) ? +1 : 0; }
Int tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }


using Tr = vector<Pt>;
constexpr Int L = 1'000'000'000;
Pt mi(const Pt &a, const Pt &b) {
  return Pt((a.x + b.x) / 2, (a.y + b.y) / 2);
}

vector<Tr> base(int n) {
  vector<Tr> ts;
  auto add = [&](const Pt &a, const Pt &b, const Pt &c) -> void {
    ts.push_back(Tr{a, b, c});
  };
  Pt A(0, 0);
  Pt B(100, 0);
  Pt C(100, 100);
  Pt D(0, 100);
  if (n == 8) {
    Pt E(50, 0);
    Pt F(50, 100);
    Pt G(49, 25);
    Pt H(51, 25);
    add(A, E, G);
    add(G, H, E);
    add(E, B, H);
    add(B, C, H);
    add(C, F, H);
    add(H, G, F);
    add(F, D, G);
    add(D, A, G);
  } else if (n == 9) {
    Pt E(33, 0);
    Pt F(0, 24);
    Pt G(25, 25);
    Pt H(34, 22);
    Pt I(25, 21);
    add(A, E, I);
    add(I, H, E);
    add(E, B, H);
    add(B, C, G);
    add(C, D, G);
    add(D, F, G);
    add(G, I, F);
    add(F, A, I);
    add(G, H, I);
  } else if (n == 10) {
    Pt E(50, 0);
    Pt F(0, 50);
    Pt G(33, 33);
    Pt H(51, 34);
    Pt I(34, 51);
    add(A, E, G);
    add(G, H, E);
    add(E, B, H);
    add(B, C, H);
    add(H, I, C);
    add(C, D, I);
    add(D, F, I);
    add(I, G, F);
    add(F, A, G);
    add(G, H, I);
  } else {
    assert(false);
  }
  for (auto &t : ts) {
    for (auto &p : t) {
      p.x *= (L / 100);
      p.y *= (L / 100);
    }
  }
  return ts;
}

int main() {
  int N;
  for (; ~scanf("%d", &N); ) {
    if (N >= 8) {
      int n;
      vector<Tr> ts;
      for (n = 8; ; ++n) {
        if ((N - n) % 3 == 0) {
          ts = base(n);
          break;
        }
      }
      int head = 0;
      for (; n < N; n += 3) {
        const Tr t = ts[head++];
        const Pt t12 = mi(t[1], t[2]);
        const Pt t20 = mi(t[2], t[0]);
        const Pt t01 = mi(t[0], t[1]);
        ts.push_back(vector<Pt>{t20, t[0], t01});
        ts.push_back(vector<Pt>{t01, t[1], t12});
        ts.push_back(vector<Pt>{t12, t[2], t20});
        ts.push_back(vector<Pt>{t12, t20, t01});
      }
      ts.erase(ts.begin(), ts.begin() + head);
      assert((int)ts.size() == N);
      
      puts("Yes");
      for (int i = 0; i < N; ++i) {
        for (int j = 0; j < 3; ++j) {
          if (j) printf(" ");
          printf("%lld %lld", ts[i][j].x, ts[i][j].y);
        }
        puts("");
      }
#ifdef LOCAL
Int area=0;
for(int i=0;i<N;++i){
 area+=abs(tri(ts[i][0],ts[i][1],ts[i][2]));
}
cerr<<"area = "<<area<<endl;
assert(area==2*L*L);
for(int i=0;i<N;++i){
 for(int j=0;j<3;++j){
  const Int d=(ts[i][(j+1)%3]-ts[i][j]).dot(ts[i][(j+2)%3]-ts[i][j]);
  if(d<=0){
   cerr<<"HELP "<<N<<" "<<i<<" "<<j<<endl;
   assert(false);
  }
 }
}
#endif
    } else {
      puts("No");
    }
  }
  return 0;
}