#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pi;
typedef pair<double,double> pd;
typedef pair<double,ll> pdl;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;

//無向
class Bridge{
private:
    typedef vector<vector<ll>> edge;
    edge E;
    ll v;
    vector<pll> count;
    vector<ll> group;
    
    ll dfs(ll w,ll depth,ll parent){
        if(count[w].F!=-1){return 1e18;}
        count[w]={depth,depth};
        bool p=true;
        for(int i=0;i<E[w].size();i++){
            if(E[w][i]==parent){
                if(!p){count[w].S=min(count[E[w][i]].F,count[w].S);}
                p=false;
            }
            else if(count[E[w][i]].F==-1){count[w].S=min(dfs(E[w][i],depth+1,w),count[w].S);}
            else{count[w].S=min(count[E[w][i]].F,count[w].S);}
        }
        return count[w].S;
    }
    
    void dfs2(ll where,ll g){
        group[where]=g;
        for(int i=0;i<E[where].size();i++){
            ll &to=E[where][i];
            if(is_bridge(where,to) || group[to]!=-1){continue;}
            dfs2(to,g);
        }
    }
    
public:
    Bridge(ll v,edge e={}):v(v),E(e){
        E.resize(v);
        count.resize(v,{-1,-1});
        group.resize(v,-1);
    }
    
    void add_edge(ll from,ll to){
        E[from].push_back(to);
        E[to].push_back(from);
    }
    
    void search(){
        dfs(0,1,-1);
    }
    
    bool is_bridge(ll u,ll v){
        if(count[u].F==count[v].F){return false;}
        if(count[u].F>count[v].F){swap(u,v);}
        if(count[u].F>=count[v].S){return false;}
        return true;
    }
    
    vector<pll> bridge(){
        vector<pll> ret;
        for(int i=0;i<v;i++){
            for(int t=0;t<E[i].size();t++){
                if(i<E[i][t] && is_bridge(i,E[i][t])){ret.push_back({i,E[i][t]});}
            }
        }
        return ret;
    }
    
    vector<ll> & Group(){
        ll count=0;
        for(int i=0;i<v;i++){
            if(group[i]==-1){dfs2(i,count); count++;}
        }
        return group;
    }
    
    void test(){
        for(int i=0;i<v;i++){
            cout<<"test "<<i<<" "<<count[i].F<<" "<<count[i].S<<endl;
        }
    }
};

vector<vector<pair<pll,pll>>> edge; //元の辺、行き先、重さ
vector<ll> node;
ll mi=E;
pll ans;
ll sum=0;

ll dfs(ll where,ll parent){
    ll count=0;
    for(auto &i:edge[where]){
        if(i.S.F==parent){continue;}
        ll W=dfs(i.S.F,where);
        if(pair<ll,pll>(mi,ans)>pair<ll,pll>(abs(sum-i.S.S-W-W),i.F)){
            mi=abs(sum-i.S.S-W-W);
            ans=i.F;
        }
        count+=W+i.S.S;
    }
    return count+=node[where];
}


int main(){
    ll v,e;
    cin>>v>>e;
    Bridge B(v);
    vector<pair<pll,ll>> Edge;
    for(int i=0;i<e;i++){
        ll u,v,w;
        cin>>u>>v>>w;
        u--; v--;
        if(u>v){swap(u,v);}
        B.add_edge(u,v);
        Edge.push_back({{u,v},w});
    }
    B.search();
    vector<ll> &G=B.Group();
    vector<pll> br=B.bridge();
    ll mx=-1;
    for(int i=0;i<G.size();i++){mx=max(mx,G[i]);}
    mx++;
    edge.resize(mx);
    node.resize(mx,0);
    mx=0;
    sort(Edge.begin(),Edge.end());
    for(int i=0;i<Edge.size();i++){
        pair<pll,ll> &w=Edge[i];
        sum+=w.S;
        if(B.is_bridge(w.F.F,w.F.S)){
            edge[G[w.F.F]].push_back({{w.F.F,w.F.S},{G[w.F.S],w.S}});
            edge[G[w.F.S]].push_back({{w.F.F,w.F.S},{G[w.F.F],w.S}});
        }
        else{
            node[G[w.F.S]]+=w.S;
            if(mx<w.S){
                mx=w.S;
                ans=w.F;
            }
        }
    }
    mi=sum-mx;
    dfs(0,-1);
    cout<<ans.F+1<<" "<<ans.S+1<<endl;
    
    
    
    return 0;
}



Measured memory_bytes: 27124