#include <iostream>
#include <algorithm>
#include <vector>
class Graph{
public:
    int v_count;// вершины
    int **matrix; // матрица смежности
    int **flow;
    bool *visited;
    int *prevs;
    Graph(int);
    void add_edge(int,int,int);
    void print_matrix();
    ~Graph();
};

Graph::~Graph(){
    for(int i = 0; i < v_count; i++){
        delete [] flow[i];
        delete [] matrix[i];
    }
    delete [] flow;
    delete [] matrix;
    delete [] visited;
    delete [] prevs;
}

void Graph::print_matrix(){
    std::cout << "  ";
    for (int i = 0; i < v_count; i++) {
        std::cout << (char)(i+'a') << " ";
    }
    std::cout << std::endl;
    for(int i = 0; i < v_count; i++){
        std::cout << (char)(i+'a') << " ";
        for(int j = 0; j < v_count; j++)
            std::cout << matrix[i][j] << " ";
        std::cout << std::endl;
    }
}

Graph::Graph(int vertex):v_count(vertex){
    matrix = new int*[v_count];
    flow = new int*[v_count];
    visited = new bool[v_count];
    prevs = new int[v_count];
    for(int i = 0; i < v_count; i++){
        visited[i] = false;
        prevs[i] = -1;
        matrix[i] = new int [v_count];
        flow[i] = new int [v_count];
        for(int j = 0; j < v_count; j++){
            flow[i][j] = 0;
            matrix[i][j] = 0;
        }
    }
}

void Graph::add_edge(int from, int to, int weight){
    matrix[from][to] = weight;
}

void deepSearch(int num,Graph &graph, int stock){
    if(graph.visited[stock])
        return;
    graph.visited[num] = true;
    for (int i = 0; i < graph.v_count; i++){
        if (!graph.visited[i] && (graph.matrix[num][i] - graph.flow[num][i] > 0 && graph.matrix[num][i] != 0 || graph.flow[num][i] < 0 && graph.matrix[i][num] != 0)){
            graph.prevs[i] = num;
            deepSearch(i,graph,stock);
        }
    }
}

bool getPath(int istock, int stock,Graph &graph){
    deepSearch(istock,graph,stock);
    for (int i = 0; i < graph.v_count; i++)
        graph.visited[i] = false;
    return (graph.prevs[stock] != -1);
}

int calcFlow(int stock, int istock,Graph &graph){
    int maxFlow = 0;
    while (getPath(istock, stock,graph)){
        int tmp = graph.matrix[graph.prevs[stock]][stock] - graph.flow[graph.prevs[stock]][stock];
        for (int num = stock; 0 <= graph.prevs[num]; num = graph.prevs[num])
            tmp = std::min(tmp, graph.matrix[graph.prevs[num]][num] - graph.flow[graph.prevs[num]][num]);
        for (int num = stock; 0 <= graph.prevs[num]; num = graph.prevs[num]){
            graph.flow[graph.prevs[num]][num] += tmp;
            graph.flow[num][graph.prevs[num]] -= tmp;
        }
        maxFlow += tmp;
        for (int i = 0; i < graph.v_count; i++)
            graph.prevs[i] = -1;
    }
    return maxFlow;
}

void printResult(Graph &graph){
    for (int i = 0; i < graph.v_count; i++)
        for (int j = 0; j < graph.v_count; j++){
            if (graph.flow[i][j] != 0 && graph.flow[i][j] < 0)
                graph.flow[i][j] = 0;
            if (graph.matrix[i][j] > 0)
                std::cout << (char)(i + '0') << " " << (char)(j + '0') << " " << graph.flow[i][j] << std::endl;
        }
}

int main(){
    int  weight, edge_count,max_v;
    char stock, source, a, b;
    size_t j = 1;
    std::vector <int> edges;
    edges.push_back(0);
    std::cin >> edge_count;
    std::cin >> source >> stock;
    for (int i = 0; i < edge_count;i++) {
        std::cin >> a >> b >> weight;
        edges.push_back((int)(a - '0'));
        edges.push_back((int)(b - '0'));
        edges.push_back(weight);
    }
    max_v = edges[0];
    for (size_t i = 1; i < edges.size(); i++) {
        if(i % 3 == 0)
            continue;
        max_v = std::max(max_v,edges[i]);
    }
    Graph graph(max_v+1);
    while(j!=edges.size()){
        graph.add_edge(edges[j],edges[j+1],edges[j+2]);
        j+=3;
    }
    //graph.print_matrix();
    std::cout << calcFlow((int)(stock - '0'),(int)(source - '0'),graph) << std::endl;
    printResult(graph);


    return 0;
}