#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef pair<int,int>P;
#define F first
#define S second

int n,m,K;
vector<int>G;
vector<P>v[2009];
set<P>NG;
map<P,int>COST;
bool used[2222];

vector<int> DP1(){
  int n=G.size();
  int dp[n+1][n+1][2];
  r(i,n+1)r(j,n+1)r(k,2)dp[i][j][k]=-1e9;
  dp[0][0][0]=0;
  for(int i=0;i<n;i++){
    for(int j=0;j<n;j++){
      for(int k=0;k<2;k++){
        dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][k]);
        if(i==0){
          dp[i+1][j+1][1]=max(dp[i+1][j+1][1],dp[i][j][k]);
        }
        else{
          if(k&&!NG.count(P(G[i],G[i-1]))){
            dp[i+1][j+1][1]=max(dp[i+1][j+1][1],dp[i][j][k]+COST[P(G[i],G[i-1])]);
          }
          if(!k){
            dp[i+1][j+1][1]=max(dp[i+1][j+1][1],dp[i][j][k]);
          }
        }
      }
    }
  }
  vector<int>V(n+1,0);
  for(int i=0;i<=n;i++){
    V[i]=max(dp[n][i][0],dp[n][i][1]);
  }
  return V;
}

int dp[2002][2002][2][2];

vector<int> DP2(){
  int n=G.size();
  r(i,n+1)r(j,n+1)r(k,2)r(l,2)dp[i][j][k][l]=-1e9;
  dp[1][1][1][1]=0;
  dp[1][0][0][0]=0;
  for(int i=1;i<n;i++){
    for(int j=0;j<n;j++){
      for(int k=0;k<2;k++){
        for(int l=0;l<2;l++){
          dp[i+1][j][0][l]=max(dp[i+1][j][0][l],dp[i][j][k][l]);
          if(k&&!NG.count(P(G[i],G[i-1]))){
            dp[i+1][j+1][1][l]=max(dp[i+1][j+1][1][l],dp[i][j][k][l]+COST[P(G[i],G[i-1])]);
          }
          if(!k){
            dp[i+1][j+1][1][l]=max(dp[i+1][j+1][1][l],dp[i][j][k][l]);
          }
        }
      }
    }
  }
  r(i,n+1)r(j,n+1){
    dp[i][j][1][1]+=COST[P(G[0],G[n-1])];
  }
  vector<int>V(n+1,0);
  for(int i=0;i<=n;i++){
    V[i]=max(dp[n][i][0][1],dp[n][i][1][0]);
    V[i]=max(V[i],dp[n][i][0][0]);
    if(!NG.count(P(G[0],G[n-1]))){
      V[i]=max(V[i],dp[n][i][1][1]);
    }
  }
  return V;
}

void dfs(int x){
  used[x]=1;
  G.push_back(x);
  r(i,v[x].size()){
    if(!used[v[x][i].F]){
      dfs(v[x][i].F);
    }
  }
}

signed main(){
  int idx=0;
  cin>>n>>m>>K;
  r(i,m){
    int a,b,c;
    cin>>a>>b>>c;
    a--;b--;
    v[a].push_back(P(b,c));
    v[b].push_back(P(a,c));
    if(c==0){
      NG.insert(P(a,b));
      NG.insert(P(b,a));
    }
    COST[P(a,b)]=c;
    COST[P(b,a)]=c;
  }
  int dp[2009][K+1];
  r(i,2009)r(j,K+1)dp[i][j]=-1e9;
  dp[0][0]=0;
  r(i,n)if(!used[i]){
    if(v[i].size()==1){
      G.clear();
      dfs(i);
      vector<int>V=DP1();
      for(int j=0;j<V.size();j++){
        for(int k=0;k<=K;k++){
          dp[idx+1][k]=max(dp[idx+1][k],dp[idx][k]);
          if(j+k>K)continue;
          dp[idx+1][j+k]=max(dp[idx+1][j+k],V[j]+dp[idx][k]);
        }
      }
      idx++;
    }
  }
  r(i,n)if(!used[i]){
    if(v[i].size()==2){
      G.clear();
      dfs(i);
      vector<int>V=DP2();
      for(int j=0;j<V.size();j++){
        for(int k=0;k<=K;k++){
          dp[idx+1][k]=max(dp[idx+1][k],dp[idx][k]);
          if(j+k>K)continue;
          dp[idx+1][j+k]=max(dp[idx+1][j+k],V[j]+dp[idx][k]);
        }
      }
      idx++;
    }
  }
  r(i,n)if(!used[i]){
    for(int k=0;k<=K;k++){
      dp[idx+1][k]=max(dp[idx+1][k],dp[idx][k]);
      if(1+k>K)continue;
      dp[idx+1][1+k]=max(dp[idx+1][1+k],dp[idx][k]);
    }
    idx++;
  }
  if(dp[idx][K]>(-30000000))cout<<dp[idx][K]<<endl;
  else cout<<"Impossible"<<endl;
}


Measured memory_bytes: 81652