#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <random>
// #include <bits/stdc++.h>

using namespace std;
#define F first
#define S second
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define per(i, a, b) for(int i = b-1; i>=a ; i--)
#define trav(a, x) for(auto& a : x)
#define allin(a , x) for(auto a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef pair<ll,ll> pll;
typedef vector<string> vs;
typedef vector<pll> vpl;
typedef vector<int> vi;

ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down

#define Unique(v) sort(all(v));v.erase(unique(all(v)),v.end());

const int maxn = 100000 + 10;

// const int inf = 1000000000;
// const ll inf = 1000000000000000000LL;

// const ll mod = 1000000007; // 10^9 + 7
// const ll mod = (119 << 23) + 1; // 998244353

int n;

int type[maxn];
int remain[maxn];

int depth[maxn];

vector<int> adj[maxn];

vector<pii> answer;

void impossible()
{
    cout << "NO" << endl;
    exit(0); 
}

int getID(string s)
{
    if( s == "-" )
        return -1;

    if( s == "Tong" )
        return 0;

    if( s == "Chang" )
        return 1;

    return 2;
}

vector<int> removeIndex(vector<int>& v, int id)
{
    vector<int> ans;

    for(int i = 0 ; i < (int)v.size() ; i++)
        if( i != id ) ans.push_back( v[i] );

    return ans;
}

bool check(vector<int> a, vector<int> b)
{
    for(int i = 0 ; i < (int)a.size() ; i++)
        if( depth[ a[i] ] <= depth[ b[i] ] ) return false;

    return true;
}

void pairing(vector<int> a, vector<int> b)
{
    for(int i = 0 ; i < (int)a.size() ; i++)
        answer.push_back( { a[i] , b[i] } );
}

void dfs(int node, int anc, int dp)
{
    depth[node] = dp;
    remain[node] = -1;

    for(int neighbor: adj[node])
        dfs( neighbor , node , dp + 1 );

    vector<int> types[3];

    if( type[node] != -1 )
        types[ type[node] ].push_back( node );

    for(int neighbor: adj[node])
    {
        if( remain[neighbor] == -1 )
            continue;

        int r = remain[neighbor];
        types[ type[r] ].push_back( r );
    }

    // cout << "-------- node = " << node << endl;

    // cout << "0 -> ";

    // for(int x: types[0])
    //     cout << x << " ";

    // cout << endl << "1 -> ";

    // for(int x: types[1])
    //     cout << x << " ";

    // cout << endl << "2 -> ";

    // for(int x: types[2])
    //     cout << x << " ";

    // cout << endl << endl;

    map<int,int> idNode;

    for(int x: types[0])
    {
        if( idNode.find( depth[x] ) != idNode.end() )
        {
            answer.push_back( { x , idNode[ depth[x] ] } );
            idNode.erase( depth[x] );
        }
        else
            idNode[ depth[x] ] = x;
    }

    if( (int)idNode.size() >= 2 )
        impossible();

    sort( types[1].begin() , types[1].end() , [&](int i, int j){
        return depth[i] < depth[j];
    });

    sort( types[2].begin() , types[2].end() , [&](int i, int j){
        return depth[i] < depth[j];
    });

    int d = (int)types[1].size() - (int)types[2].size();

    if( abs(d) >= 2 )
        impossible();

    if( abs(d) == 1 && (int)idNode.size() == 1 )
        impossible();

    if( d == 0 )
    {
        if( !check( types[1] , types[2] ) )
            impossible();

        pairing( types[1] , types[2] );
    }

    if( (int)idNode.size() == 1 )
    {
        auto it = idNode.begin();
        remain[node] = it->second;

        // cout << "entrei" << endl;

        return;
    }

    if( d == 0 )
        return;

    if( d == 1 )
    {
        int l = 0, r = (int)types[1].size() - 1;

        if( !check( removeIndex( types[1] , l ) , types[2] ) )
            impossible();

        while( l < r )
        {
            int m = ( l + r )/2;
            if( l == r - 1 ) m = r;

            if( check( removeIndex( types[1] , m ) , types[2] ) )
                l = m;
            else
                r = m - 1;
        }

        remain[node] = types[1][l];
        types[1] = removeIndex( types[1] , l );
    }

    if( d == -1 )
    {
        // cout << "aqui" << endl;
        int l = 0, r = (int)types[2].size() - 1;

        if( !check( types[1] , removeIndex( types[2] , r ) ) ) 
            impossible();

        while( l < r )
        {
            int m = ( l + r )/2;    
            
            if( check( types[1] , removeIndex( types[2] , m ) ) )
                r = m;
            else
                l = m + 1;
        }

        remain[node] = types[2][r];
        types[2] = removeIndex( types[2] , r );
    }

    // cout << "remain " << remain[node] << endl;
    pairing( types[1] , types[2] );
}

void solve(int testcase)
{
    cin >> n;

    type[1] = -1;

    for(int i = 1 ; i < n ; i++)
    {
        int u, v;
        string aux;
        cin >> u >> v >> aux;

        adj[v].push_back( u );
        type[u] = getID( aux );
    }

    dfs( 1 , 1 , 0 );

    if( remain[1] != -1 )
        impossible();

    cout << "YES" << endl;

    for(auto [x, y]: answer)
        cout << x << " " << y << endl;
}

int main()
{
    ios_base::sync_with_stdio(false);  
    cin.tie(NULL);

    int t = 1;
    // cin >> t;

    for(int testcase = 1 ; testcase <= t ; testcase++)
        solve( testcase );
}