#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <fstream>
using namespace std;
/*
 ifstream fin("in.ann");
 ofstream fout("out.ann");
 */


class Neuron {
private:
    int battery; // Маша: аккумулятор
    int condition; // Маша: состояние
    int number; // Маша: номер нейрона

public:
    Neuron(): battery(0), condition(0) {};
    Neuron(int value, int number): battery(value), number(number), condition(0) {};

    Neuron activate_function(Neuron a);
    Neuron binary_function(Neuron a);

    int get_condition(){ return condition; }
    int get_battery(){ return battery; }
    int get_number(){ return number; }

    void add_battety(int a){ battery += a; }
};

Neuron Neuron::activate_function(Neuron a){
    a.condition = a.battery;
    return a;
}

Neuron Neuron::binary_function(Neuron a){
    if (a.battery > 50){
        a.condition = 100;
    }
    else {
        a.condition = 0;
    }
    return a;
}


class Synapse {
private:
    int donor;
    int acceptor;
    int weight_edge;
public:
    Synapse() : donor(0), acceptor(0), weight_edge(0) {};
    Synapse(int donor, int acceptor, int weight_edge): donor(donor), acceptor(acceptor), weight_edge(weight_edge) {};

    int get_donor(){ return donor; }
    int get_acceptor(){ return acceptor; }
    int get_weight(){ return weight_edge; }

    friend istream &operator >> (istream &in, Synapse& a){
        in >> a.donor >> a.acceptor >> a.weight_edge;
        return in;
    }
    friend ostream &operator << (ostream &out, Synapse a){
        out << a.donor << ' ' << a.acceptor << ' ' << a.weight_edge << '\n';
        return out;
    }
};


class Net {
public:
    Neuron neurons[100];
    vector<Synapse> synapses; // Маша: Список ребер

    Net(string path){
        ifstream in;
        in.open(path.c_str());
        while (!in.eof()){
            Synapse add;
            in >> add;
            synapses.push_back(add);
        }
    }

    void run(vector<Neuron> first){
        queue <Neuron> que; // очередь

        for (Neuron n : first){
            que.push(n);
        }
        Neuron start = que.front();
        Neuron vertex = que.front(); que.pop();
        neurons[start.get_number()] = start;

        for (vertex; que.size() > 0; vertex = que.front(), que.pop()){
            for (Synapse syn : synapses){
                if (syn.get_donor() == vertex.get_number()){
                    Neuron* next = &neurons[syn.get_acceptor()];
                    next->add_battety((vertex.get_condition() * syn.get_weight()) / 100);
                    que.push(*next);
                }
            }
        }
    }

    void add(Synapse newSyn){ synapses.push_back(newSyn); }

    void remove(Synapse delsyn){
        for (int i = 0; i < synapses.size(); i++){
            if (delsyn.get_donor() == synapses[i].get_donor() && delsyn.get_acceptor() == synapses[i].get_acceptor()
                && delsyn.get_weight() == synapses[i].get_weight()){ // Егор: почему не if(delsyn == synapses[i]) ?
                synapses.erase(synapses.begin() + i);
            }
        }
    }

    // Егор: Проверка сети на связность после изменения
    /*bool test(){
        bool good_donor;
        bool good_acceptor;
        for (int i = 0; i < 100; i++){
            good_donor = false;
            good_acceptor = false;
            if (neurons[i].get_battery() > 0){
                for (int j = 0; j < synapses.size(); j++){
                    if (synapses[i].get_donor() == neurons[i].get_number()){
                        good_donor = true;
                    }
                    if (synapses[i].get_acceptor() == neurons[i].get_number()){
                        good_acceptor = true;
                    }
                }
                if (!good_donor || !good_acceptor){
                    return false;
                }
            }

        }
        return true;
    }*/
    bool test(){
        bool isDonor[100], isAcceptor[100];

        for (Synapse syn : synapses){
            if (syn.get_acceptor() <= syn.get_donor())
                return false;

            isDonor[syn.get_donor()] = 1;
            isAcceptor[syn.get_acceptor()] = 1;
        }

        bool foundInput=0, foundOutput=0;
        for (int i=10; i<20; i++){
            if (isDonor[i]) foundInput = 1;
        }
        for (int i=80; i<90; i++){
            if (isAcceptor[i]) foundOutput = 1;
        }
        for (int i=20; i<80; i++){
            if (isDonor[i] ^ isAcceptor[i])
                return false;
        }

        return foundInput && foundOutput;
    }

};

string analyzer(string path);
// Егор: path - адрес входного файла
// Егор: Функция обрабатывает его и записывает в файл .ann, возвращает имя файла


class NeuroBot {
    /* Егор: Ядро (модуль). Хранит в себе параметры объектов,
     * Егор: реализует игровую логику и общение c пользователем.
     * Егор: Ядро хранит мозги объектов и реализует обработку нейросетей.
     */
};

int main(){
    Synapse a;
    cin >> a;
    while (cin >> a){
        cout << a;
        cin >> a; // Маша: Проверка работы перегруженных операторов
    }
    return 0;
}