#include<bits/stdc++.h>
#define ull unsigned long long
#define ui unsigned int
#define ld long double
#define ll long long
#define lll __int128
#define fi first
#define se second
#define e emplace
#define eb emplace_back
#define db double
#define ef emplace_front
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vp vector<pii>
#define vt vector<tup>
#define all(x) x.begin(),x.end()
#define mp make_pair

#define FastI
#define FastO
//#define int ll
bool ST;
static const ll MOD=1e9+7,Phi=998244352,inv2=499122177,Root=3,iRoot=332748118;
static const ll inf=1073741823,Inf=4294967296,INF=4557430888798830399;
static const ld eps=1e-9,pi=3.1415926535;
char in[1<<20],*p1=in,*p2=in;
char out[1<<20],*p3=out;
using namespace std;
struct tup
{
	int x,y,z;
	tup(int X=0,int Y=0,int Z=0)
	{x=X,y=Y,z=Z;}
};
#ifdef FastI
#define getchar() (p1==p2&&(p2=(p1=in)+fread(in,1,1<<20,stdin),p1==p2)?EOF:*p1++)
#endif
#ifdef FastO
#define putchar(x) (p3-out==1<<20?fwrite(out,1,1<<20,stdout),p3=out,0:0,*p3++=x)
#define puts(x) write(x,'\n')
#endif
namespace FastIO
{
	template<typename T> inline void write(T x,char ch=' ')
	{
		if(is_same<char,T>::value)putchar(x);
		else
		{
			if(x<0)x=-x,putchar('-');
			static char st[25];
			int top=0;
			do st[top++]=x%10+'0',x/=10;while(x);
			while(top)putchar(st[--top]);
		}
		ch!='~'?putchar(ch):0;
	}
	inline void write(const char*x,char ch=' ')
	{
		for(int i=0;x[i]!='\0';++i)putchar(x[i]);
		ch!='~'?putchar(ch):0;
	}
	inline void read(char&s){do s=getchar();while(s=='\n'||s==' ');}
	inline void read(char s[])
	{
		int len=0;char st;
		do st=getchar();while(st=='\n'||st==' ');
		s[++len]=st,st=getchar();
		while(st!='\n'&&st!=' '&&st!='\r')s[++len]=st,st=getchar();
		s[++len]='\0';
	}
	template<typename T> inline void read(T &s)
	{
		char ch=getchar();s=0;
		while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
		bool tf=(ch=='-'&&(ch=getchar()));
		while(ch>='0'&&ch<='9')s=(s<<1)+(s<<3)+ch-'0',ch=getchar();
		s=tf?-s:s;
	}
	inline void edl(){putchar('\n');}
	template<typename T1,typename T2> inline void read(pair<T1,T2> &s){read(s.fi),read(s.se);}
	template<typename T,typename...Args> inline void write(T x,Args...args){write(x,'~'),write(args...);}
	template<typename T,typename...Args> inline void read(T&x,Args&...args){read(x),read(args...);}
	#ifdef FastO
	struct Writer{~Writer(){fwrite(out,1,p3-out,stdout);}}Writ;
	#endif
}
using namespace FastIO;
namespace MTool
{
    inline int Cadd(int a,int b){return (ll)a+b>=MOD?(ll)a+b-MOD:a+b;}
    inline int Cdel(int a,int b){return a-b<0?a-b+MOD:a-b;}
    inline int Cmul(int a,int b){return 1ll*a*b%MOD;}
    inline int sqr(int a){return 1ll*a*a%MOD;}
    inline void Madd(int&a,int b){a=((ll)a+b>=MOD?(ll)a+b-MOD:a+b);}
    inline void Mdel(int&a,int b){a=(a-b<0?a-b+MOD:a-b);}
    inline void Mmul(int&a,int b){a=1ll*a*b%MOD;}
    inline int Cmod(int x){return (x%MOD+MOD)%MOD;}
    inline void Mmod(int&x){x=(x%MOD+MOD)%MOD;}
    template<typename T> inline bool Mmax(T&a,T b){return a<b?a=b,1:0;}
    template<typename T> inline bool Mmin(T&a,T b){return a>b?a=b,1:0;}
    template<typename...Args> inline void Madd(int&a,int b,Args...args){Madd(a,b),Madd(a,args...);}
    template<typename...Args> inline void Mmul(int&a,int b,Args...args){Mmul(a,b),Mmul(a,args...);}
    template<typename...Args> inline void Mdel(int&a,int b,Args...args){Mdel(a,b),Mdel(a,args...);}
    template<typename...Args> inline int Cadd(int a,int b,Args...args){return Cadd(Cadd(a,b),args...);}
    template<typename...Args> inline int Cmul(int a,int b,Args...args){return Cmul(Cmul(a,b),args...);}
    template<typename...Args> inline int Cdel(int a,int b,Args...args){return Cdel(Cdel(a,b),args...);}
    template<typename...Args,typename T> inline bool Mmax(T&a,T b,Args...args){return Mmax(a,b)|Mmax(a,args...);}
    template<typename...Args,typename T> inline bool Mmin(T&a,T b,Args...args){return Mmin(a,b)|Mmin(a,args...);}
    inline int power(int x,int y){int s=1;for(;y;y>>=1,Mmul(x,x))if(y&1)Mmul(s,x);return s;}
}
using namespace MTool;
namespace WrongAnswer_90
{
	int n,m;
	namespace Flow
	{
		int S,T,cnt=1,head[1000210],to[4000210],nex[4000210],v[4000210],d[1000210],now[1000210];
	    inline void Add(int x,int y,int z){to[++cnt]=y,nex[cnt]=head[x],head[x]=cnt,v[cnt]=z;}
	    inline void add(int x,int y,int z){Add(x,y,z),Add(y,x,1);}
	    queue<int> q;
	    int bfs()
	    {
	        while(!q.empty())q.pop();
	        q.e(S),memset(d,0,sizeof(d)),d[S]=1,now[S]=head[S];
	        while(!q.empty())
	        {
	            int k=q.front();q.pop();
	            for(int i=head[k];i;i=nex[i])
	            {
	                if(v[i]&&!d[to[i]])
	                {
	                    d[to[i]]=d[k]+1,now[to[i]]=head[to[i]],q.e(to[i]);
	                    if(to[i]==T)return 1;
	                }
	            }
	        }
	        return 0;
	    }
	    int dinic(int k,int flow)
	    {
	        if(k==T)return flow;
	        int rest=flow,t;
	        for(int i=now[k];i&&rest;i=nex[i])
	        {
	            now[k]=i;
	            if(d[to[i]]!=d[k]+1||!v[i])continue;
	            t=dinic(to[i],min(v[i],rest));
	            if(!t)d[to[i]]=0;
	            rest-=t,v[i]-=t,v[i^1]+=t;
	        }
	        return flow-rest;
	    }
	}
    namespace Tarjan
    {
		const int N=1000000,M=2000000;
	    int cnt=1,num,col,low[N+10],dfn[N+10],head[N+10],to[M+10],nex[M+10];
	    int c[N+10];
	    inline void add(int x,int y){to[++cnt]=y,nex[cnt]=head[x],head[x]=cnt;}
	    stack<int> st;
	    vi ve[N+10];
	    void tarjan(int x,int fromi)
	    {
	        dfn[x]=low[x]=++num,st.e(x);
	        for(int i=head[x];i;i=nex[i])
	        {
	            if(i==(fromi^1))continue;
	            if(!dfn[to[i]])tarjan(to[i],i),low[x]=min(low[x],low[to[i]]);
	            else low[x]=min(low[x],dfn[to[i]]);
	        }
	        if(low[x]==dfn[x])
	        {
	            int y;++col;
	            do ve[col].eb(y=st.top()),c[y]=col,st.pop();while(y!=x);
	        }
	    }
	}
	vp ve[1000010];
	tup b[1000010];
	vi vec;
	void print(int x,int fromi)
	{
		if(x==Flow::T)return;
		vec.eb(x);
//		cerr<<x<<endl;
		for(int i=Flow::head[x];i;i=Flow::nex[i])
		if(!Flow::v[i])return Flow::v[i]=inf,print(Flow::to[i],i);
	}
	inline void mian()
	{
		read(n,m);
		for(int i=1;i<=m;++i)
		{
			read(b[i].x,b[i].y,b[i].z);
			Tarjan::add(b[i].x,b[i].y);
			Tarjan::add(b[i].y,b[i].x);
		}
		for(int i=1;i<=n;++i)if(!Tarjan::dfn[i])
		Tarjan::tarjan(i,0);
		for(int i=1;i<=m;++i)
		{
			if(Tarjan::c[b[i].x]==Tarjan::c[b[i].y])
			ve[Tarjan::c[b[i].x]].eb(mp(b[i].z,i));
		}
		int X=-1,Y=-1,ans=-1;
		for(int i=1;i<=Tarjan::col;++i)
		{
			sort(all(ve[i]));
			if(ve[i].size()<2)continue;
			if(Mmax(ans,ve[i].back().fi-ve[i][0].fi))
			X=ve[i].back().se,Y=ve[i][0].se;
		}
		Flow::S=n+1,Flow::T=n+2;
		Flow::add(Flow::S,b[X].x,1);
		Flow::add(Flow::S,b[X].y,1);
		Flow::add(b[Y].x,Flow::T,1);
		Flow::add(b[Y].y,Flow::T,1);
//		cerr<<X<<" "<<Y<<endl;
		for(int i=1;i<=m;++i)if(i!=X&&i!=Y)
		{
			if(Tarjan::c[b[i].x]==Tarjan::c[b[X].x]&&Tarjan::c[b[i].y]==Tarjan::c[b[X].x])
			Flow::add(b[i].x,b[i].y,1);
		}
		int x=0,sum=0,fl=0;
		while(Flow::bfs())while((x=Flow::dinic(Flow::S,inf)))sum+=x;
//		if(sum!=2)cout<<"??"<<sum<<endl,exit(0);
		assert(sum==2);
//		exit(0);
		for(int i=Flow::head[Flow::S];i;i=Flow::nex[i])
		{
			if(!Flow::v[i])
			{
//				cerr<<"!"<<Flow::to[i];exit(0);
				print(Flow::to[i],i);
				if(!fl)fl=1,reverse(all(vec));
				else ++fl,assert(fl==2);
			}
		}
		write(ans,'\n');
		write(vec.size(),'\n');
		for(auto p:vec)write(p);
	}
	
	inline void Mian()
	{
		int T=1;
//		read(T);
		while(T--)mian();
	}
}
bool ED;
signed main()
{
//	ios::sync_with_stdio(0); 
//	freopen("1.in","r",stdin);
//	freopen("1.out","w",stdout);
	double st=clock();
	WrongAnswer_90::Mian();
	double ed=clock();
 	cerr<<endl;
 	cerr<<"Time: "<<ed-st<<" ms\n";
 	cerr<<"Memory: "<<abs(&ST-&ED)/1024.0/1024.0<<" MB\n";
	return 0;
}