#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
using namespace std;

#include "message.h"

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

// change the include here!!!
#include "skup.h"

const int MR = 110;

// kto moze mi wysylac wiadomosci
bool canSend[MR];

// kto jest ze mna w SCC
bool SCC[MR];

// wartosci w poszczegolnych krajach
vector<int> V[MR];

// jakie nowe kraje dostalismy
set<char> who;

// czy ma go ignorowac, bo wierzholek juz sie nie updatuje
bool ign[MR];

vector<char> Exchange(int id, const vector<char> &countries, int N)
{
	// wymieniaj sie wszystkimi danymi ze wszystkimi countries
	// zwroc posortowany wektor wszystkich krajow z ktorymi sie wymieniles

	// nie wymieniaj sie z samym soba - moze byc w countries

	// wysylamy kraje w Who

	// wysylaj swoje dane wszystkim krajom z countries, oprocz siebie
	for (char country : countries)
		if (country != id)
		{
			PutChar(country, who.size());
			for (char c : who)
			{
				PutChar(country, c);
				PutInt(country, V[c].size());
				for (int share : V[c])
					PutInt(country, share);
			}
			Send(country);
		}

	// odznacz kraje, ktore juz mamy
	set<char> prevWho;
	REP(i, N)
		if (!V[i].empty())
			prevWho.insert(i);

	// zobacz czy cos nowego dostalismy
	who.clear();

	// odbieraj dane od wszystkich z countries oprocz siebie
	// rowniez zignoruj kraje, z ktorych nie mozesz odbierac wiadomosci - one sa bezwartosciowe
	// niech lepiej zapychaja kolejke - nic innego nie da sie zrobic
	for (char country : countries)
		if (country != id && canSend[country] && !ign[country])
		{
			Receive(country);

			char nc = GetChar(country);
			
			// spr czy cos nowego nam wyslal
			if (!nc)
				ign[country] = 1;

			REP(i, nc)
			{
				
				char newcountry = GetChar(country);
				who.insert(newcountry);

				// zobacz, czy nie mielismy info o tym panstwie
				bool add = V[newcountry].empty();

				int numberOfShares = GetInt(country);

				REP(j, numberOfShares)
				{
					int sharePrice = GetInt(country);
					if (add)
						V[newcountry].push_back(sharePrice);
				}
			}
		}

	// wyrzuc z who wszystkie kraje, ktore juz byly
	for (char c : prevWho)
		who.erase(c);

	vector<char> res;

	REP(i, N)
		if (!V[i].empty())
			res.push_back(i);

	return res;
}

LL go(int N)
{
	vector<int> tmp;
	REP(i, N)
		for (int sp : V[i])
			tmp.push_back(sp);

	sort(tmp.begin(), tmp.end());

	LL res = 0;
	REP(i, tmp.size())
		res += tmp[i] * (LL)(tmp.size() - i);

	return res;
}

int main()
{
	int id = MyNodeId();
	int ileI = NumberOfNodes();

	// wyznacz SCC

	// wysylaj wiadomosci wszystkim pozostalym
	REP(i, ileI)
		if (i != id)
		{
			PutChar(i, (char)1);
			Send(i);
		}

	// odbieraj i wysylaj z powrotem, to co dostales
	REP(i, ileI)
		if (i != id)
		{
			Receive(i);
			char v = GetChar(i);
			// zobacz, kto moze do Ciebie wysylac
			if (v)
				canSend[i] = 1;
			PutChar(i, v);
			Send(i);
		}

	// teraz drugi raz odbierz wiadomosc, ktora dostal od Ciebie i wyslal z powrotem
	REP(i, ileI)
		if (i != id)
		{
			Receive(i);
			char v = GetChar(i);
			// jesli to, co wyslales przyszlo do Ciebie, to jest dwukierunkowa krawedz
			// zwroc uwage, ze on tez odznaczy sobie Ciebie w SCC
			if (v)
				SCC[i] = 1;
		}

	// wez swoje dane
	int ileC = NumberOfCompanies();
	REP(i, ileC)
		V[id].push_back(GetShareCost(i));

	who.insert(id);

	SCC[id] = 1;
	// wymieniaj sie danymi z wierzcholkami z SCC - rob tak, dopoki nie dodasz zadnego nowego wierzcholka
	while (true)
	{
		vector<char> oldSCC;
		REP(i, ileI)
			if (SCC[i])
				oldSCC.push_back(i);

		auto newSCC = Exchange(id, oldSCC, ileI);

		// special case - po pierwszej iteracji te zbiory beda dokladnie takie same
		// wiec jesli nie masz info o wszystkich, to nie przerywaj od razu
		if (who.empty())
			break;

		// zrob update scc
		for (char v : newSCC)
			SCC[v] = 1;
	}

	// zobacz, czy przypadkiem wszystko nam sie nie zwinelo
	int ileSCC = 0;
	REP(i, ileI)
		ileSCC += SCC[i];

	if (ileSCC == ileI)
	{
		if (!id)
		{
			// jako master wyznacz wynik
			printf("%lld\n", go(ileI));
		}

		return 0;
	}

	// nie mielismy tyle szczescia - wymieniaj sie z wszystkimi poza SCC
	vector<char> countries;
	REP(i, ileI)
		if (!SCC[i])
			countries.push_back(i);

	// wyznacz ktore kraje mamy
	who.clear();
	REP(i, ileI)
		if (!V[i].empty())
			who.insert(i);

	// wylicz ile razy mamy te same kraje
	int ileSame = 0;
	while (true)
	{
		Exchange(id, countries, ileI);

		ileSame += who.empty();

		// spr czy nikt na nas juz nie bedzie czekal
		// min jeden raz musimy wyslac to samo, zeby odbiorcy dali nas do ignorowania
		// z SCC bylo inaczej
		if (ileSame > 1)
			break;
	}

	// ktos musi miec info o wszystkich i w takim przypadku, wszyscy z jego skladowej tez
	// a zatem, ten ktory jest minimalny moze go wypisac
	int ileMasz = 0;
	REP(i, ileI)
		ileMasz += !V[i].empty();

	if (ileMasz == ileI)
	{
		REP(i, ileI)
			if (SCC[i])
			{
				if (id == i)
					printf("%lld\n", go(ileI));
				break;
			}
	}

	return 0;
}