#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 155
#define SIZE 21

int V,E,K;
int POW[SIZE];
int pow_max_value[SIZE][NUM][NUM];
int sum_value[NUM][NUM],work[NUM][NUM];
int dp[NUM][NUM],pre[NUM][NUM];

void init_work(){
	for(int i = 0; i < V; i++){
		for(int k = 0; k < V; k++){
			if(i != k){
				work[i][k] = -BIG_NUM;
			}else{
				work[i][k] = 0;
			}
		}
	}
}

int main(){

	POW[0] = 1;
	for(int i = 1; i < SIZE; i++){
		POW[i] = POW[i-1]*2;
	}

	scanf("%d %d %d",&V,&E,&K);

	for(int i = 0; i < SIZE; i++){
		for(int a = 0; a < V; a++){
			for(int b = 0; b < V; b++){
				if(a != b){
					pow_max_value[i][a][b] = -BIG_NUM;
				}else{
					pow_max_value[i][a][b] = 0;
				}
			}
		}
	}

	int tmp_from,tmp_to,value;

	for(int loop = 0; loop < E; loop++){

		scanf("%d %d %d",&tmp_from,&tmp_to,&value);

		pow_max_value[0][tmp_from][tmp_to] = max(pow_max_value[0][tmp_from][tmp_to],value);
	}


	//DAG対策
	for(int count = 0; count <= 150; count++){
		for(int loc = 0; loc < V; loc++){
			if(count > 0){
				dp[count][loc] = -BIG_NUM;
			}else{
				dp[count][loc] = 0;
			}
		}
	}

	for(int count = 1; count <= 150; count++){
		for(int from = 0; from < V; from++){
			if(dp[count-1][from] == -BIG_NUM)continue;
			for(int to = 0; to < V; to++){
				if(pow_max_value[0][from][to] == -BIG_NUM)continue;
				if(dp[count][to] < dp[count-1][from]+pow_max_value[0][from][to]){
					dp[count][to] = dp[count-1][from]+pow_max_value[0][from][to];
					pre[count][to] = from;
				}
			}
		}
	}

	for(int count = 1; count <= 150; count++){
		int tmp_max = 0;
		int tmp_node;
		for(int loc = 0; loc < V; loc++){
			if(tmp_max < dp[count][loc]){
				tmp_max = dp[count][loc];
				tmp_node = loc;
			}
		}
		if(tmp_max >= K){

			printf("%d\n",count);
			if(count > 100){
				return 0;
			}

			stack<int> S;

			S.push(tmp_node);

			for(int i = count; i >= 1; i--){
				S.push(pre[i][tmp_node]);
				tmp_node = pre[i][tmp_node];
			}

			printf("%d",S.top());
			S.pop();

			while(!S.empty()){
				printf(" %d",S.top());
				S.pop();
			}
			printf("\n");

			return 0;
		}
	}

	//ダブリング
	for(int i = 1; i < SIZE; i++){
		for(int mid = 0; mid < V; mid++){
			for(int start = 0; start < V; start++){
				if(pow_max_value[i-1][start][mid] == -BIG_NUM)continue;
				for(int goal = 0; goal < V; goal++){
					if(pow_max_value[i-1][mid][goal] == -BIG_NUM)continue;

					pow_max_value[i][start][goal] = max(pow_max_value[i][start][goal],
							pow_max_value[i-1][start][mid]+pow_max_value[i-1][mid][goal]);
				}
			}
		}
	}

	int left = 1,right = K,mid = (left+right);
	int ans = -1;
	bool is_First;
	int maximum = 0;

	while(left <= right){ //2分探索

		int tmp_count = mid;
		is_First = true;

		for(int i = 20; i >= 0; i--){
			if(tmp_count < POW[i])continue;
			tmp_count -= POW[i];

			if(is_First){

				//初めてのPOW
				for(int from = 0; from < V; from++){
					for(int to = 0; to < V; to++){
						sum_value[from][to] = pow_max_value[i][from][to];
					}
				}

				is_First = false;
				continue;
			}

			init_work(); //★★workを介さないと、足し過ぎが発生する★★

			for(int mid = 0; mid < V; mid++){
				for(int start = 0; start < V; start++){
					if(sum_value[start][mid] < 0)continue;
					for(int goal = 0; goal < V; goal++){
						if(pow_max_value[i][mid][goal] < 0)continue;

						work[start][goal] = max(work[start][goal],sum_value[start][mid]+pow_max_value[i][mid][goal]);

					}
				}
			}

			for(int from = 0; from < V; from++){
				for(int to = 0; to < V; to++){
					sum_value[from][to] = work[from][to];
				}
			}
		}

		maximum = 0;
		for(int from = 0; from < V; from++){
			for(int to = 0; to < V; to++){
				maximum = max(maximum,sum_value[from][to]);
			}
		}

		if(maximum >= K){
			ans = mid;
			right = mid-1;
		}else{
			left = mid+1;
		}
		mid = (left+right)/2;
	}

	printf("%d\n",ans);

	return 0;
}



Measured memory_bytes: 5588