#include <iostream>
#include <string>
#include <cmath>
#include <cstdlib>


using namespace std;

int a, b, c, fl, chislo, lg, n;
char ch;
int arr[100001];
int arr1[100001];
int parent[100001];
int mas[100001][3];
int sp[30][50001];
int log1[100001];
int unlog[100001];
int poiskovik[100001];

struct Node
{
    int x = 0, y = 0, p = 0;
    Node *l, *r;
};


void debug_tree(Node *t) {
    if (t == NULL) return;

    cout << " { ";
    debug_tree(t -> l);
    cout << " } ";

    cout << t -> x;

    cout << " { ";
    debug_tree(t -> r);
    cout << " } ";
}

void split(Node *node, int k, Node *&l, Node *&r)
{
    l = NULL;
    r = NULL;
    if (node == NULL)
        return;
    if (node -> x < k)
    {
        split(node -> r, k, node -> r, r);
        l = node;
    }
        else
        {
            split(node -> l, k, l, node -> l);
            r = node;
        }
}

Node* Merge(Node *l, Node *r)
{
    if (l == NULL)
        return r;
    if (r == NULL)
        return l;
    if (l -> y > r -> y)
    {
        l -> r = Merge(l -> r, r);
        return l;
    }
        else
        {
            r -> l = Merge(l, r -> l);
            return r;
        }
}

Node* next(Node *t, int k)
{
    Node *l, *r, *l1;
    split(t, k + 1, l, r);
    l1 = r;
    if (r == NULL) return Merge(l, r);
    while (l1 -> l != NULL)
        l1 = l1 -> l;
    chislo = l1 -> x;
    return Merge(l, r);
}

Node* prev(Node *t, int k)
{
    Node *l, *r, *l1;
    split(t, k, l, r);
    l1 = l;
    if (l == NULL) return Merge(l, r);
    while (l1 -> r != NULL)
        l1 = l1 -> r;
    chislo = l1 -> x;
    return Merge(l, r);
}

Node* inser(Node *t, int k)
{
    Node *l, *r;
    split(t, k, l, r);
    Node* m = new Node;
    m -> x = k;
    m -> y = rand();
    m -> l = NULL;
    m -> r = NULL;
    return Merge(l, Merge(m, r));
}

Node* delet(Node *t, int k)
{
    Node *l, *r, *r1, *l1;
    split(t, k, l, r);
    l1 = l;
    r1 = r;
    split(r1, k + 1, l, r);
    return Merge(l1, r);
}

void vivedi_pls_otvet(Node *start, int n)
{
    if (n == -30002)
        mas[parent[start -> x + 30000]][0] = 0;
    else
    mas[parent[start -> x + 30001]][0] = parent[n + 30001] + 1;
    if (start -> l != NULL)
        mas[parent[start -> x + 30001]][1] = parent[start -> l -> x + 30001] + 1;
    else
        mas[parent[start -> x + 30001]][1] = 0;
    if (start -> r != NULL)
        mas[parent[start -> x + 30001]][2] = parent[start -> r -> x + 30001] + 1;
    else
        mas[parent[start -> x + 30001]][2] = 0;
    if (start -> l != NULL) vivedi_pls_otvet(start -> l, start -> x);
    if (start -> r != NULL) vivedi_pls_otvet(start -> r, start -> x);
}

Node* searc(Node *t, int n)
{
    Node *l, *r, *r1, *l1;
    split(t, n, l, r);
    l1 = r;
    if (r == NULL) return Merge(l, r);
    while (l1 -> l != NULL)
        l1 = l1 -> l;
    if (n == l1 -> x) fl = 1;
    return Merge(l, r);
}

void qsort(int l, int r)
{
    if (r - l <= 1) return;
    int i1 = l;
    int j1 = l;
    int x = arr[l + rand() % (r - l)];
    for (int k = l; k < r; ++k)
    {
        if (arr[k] == x)
        {
            swap(arr[k], arr[j1]);
            swap(arr1[k], arr1[j1]);
            ++j1;
        }
        if (arr[k] < x)
        {
            swap(arr[k], arr[i1]);
            swap(arr1[k], arr1[i1]);
            ++i1;
            if (j1 < i1) ++j1;
        }
    }
    qsort(l, i1);
    qsort(j1, r);
}

Node* dfs(int l, int r)
{
    Node *m = new Node;
    if (r - l <= 0)
    {
        m -> l = NULL;
        m -> r = NULL;
        m -> x = arr[r];
        m -> y = arr1[r];
        return m;
    }
    int max1 = 10000000;
    int nomer = -1;
    max1 = min(sp[unlog[r - l]][l], sp[unlog[r - l]][r - log1[unlog[r - l]] + 1]);
    nomer = poiskovik[max1 + 30001];
    m -> x = arr[nomer];
    m -> y = arr1[nomer];
    if (nomer - 1 >= l)
        m -> l = dfs(l, nomer - 1);
    else
        m -> l = NULL;
    if (r >= nomer + 1)
        m -> r = dfs(nomer + 1, r);
    else
        m -> r = NULL;
    return m;
}

int main()
{
    freopen("cartesian.in", "r", stdin);
    freopen("cartesian.out", "w", stdout);
    Node *start = NULL;
    Node *root = NULL;
    int kol = 0;
    cin >> a;
    for (int i = 0; i < a; ++i)
    {
        cin >> arr[i] >> arr1[i];
        parent[arr[i] + 30001] = i;
    }
    qsort(0, a);
    for (int i = 0; i < a; ++i)
    {
    	poiskovik[arr1[i] + 30001] = i;
    }
    for (int i = 0; i < a; ++i)
    	sp[0][i] = arr1[i];
    int chislo = 1;
	for (int i = 1; i < 21; ++i)
	{
		if (chislo <= a)
		{
			++lg;
			chislo = chislo * 2;
			log1[lg] = chislo;
		}
	}
	log1[0] = 1;
	chislo = 0;
	unlog[1] = 0;
	int p = 2;
	for (int i = 2; i < 100001; ++i)
	{
		if (i >= p)
		{
			p = p * 2;
			++chislo;
		}
		unlog[i] = chislo;
	}
	for (int i = 1; i < lg; ++i)
	{
		n += log1[i - 1];
		for (int j = 0; j < a - n; ++j)
		{
			sp[i][j] = min(sp[i - 1][j], sp[i - 1][j + log1[i - 1]]);
		}
	}
    start = dfs(0, a - 1);
    vivedi_pls_otvet(start, -30002);
    cout << "YES" << endl;
    for (int i = 0; i < a; ++i)
    {
        cout << mas[i][0] << " " << mas[i][1] << " " << mas[i][2] << endl;
    }
}