Program CODEVS1187;

const maxn=;

type arr=record

        u,v,w,next:int64;

        end;

type arr1=record

        next:array[..] of longint;

        end;

var eg:array[..maxn*] of arr;

    last:array[..maxn] of longint;

    fa:array[ ..maxn] of longint;

    f:array[..maxn] of int64;

    T:array[..maxn*] of arr1;

    a:array[..] of longint;

    n,u,v,w,root,mx,num,m,k,sum,ans,now:int64;

    i,j:longint;

procedure add(u,v,w:longint);

begin

  inc(j);

  eg[j].u:=u;

  eg[j].v:=v;

  eg[j].w:=w;

  eg[j].next:=last[u];

  last[u]:=j;

end;

procedure dfs(u:longint;sum:int64;fa:longint);

var i:longint;

begin

  f[u]:=sum;

  i:=last[u];

  while i<> do

    begin

      if eg[i].v<>fa then

      dfs(eg[i].v,sum xor eg[i].w,u);

      i:=eg[i].next;

    end;

end;

begin

  readln(n);

  for i:= to n- do

    begin

      readln(u,v,w);

          add(u,v,w);

      add(v,u,w);

    end;

  root:=;

  dfs(root,,);

{---------------------------------------------------}

  mx:=;

  for i:= to n do if f[i]>mx then mx:=f[i];

  j:=mx; num:=;

  while j> do

    begin

      inc(num);

      j:=j div ;

    end;

  m:=num; k:=;

  for i:= to n do

    begin

      fillchar(a,sizeof(a),);

      j:=f[i]; num:=;

      while j> do

        begin

          inc(num);

          a[num]:=j mod ;

          j:=j div ;

        end;

      now:=;

      for j:=m downto  do

        if T[now].next[a[j]]<> then now:=T[now].next[a[j]] else

          begin

            inc(k);

            T[now].next[a[j]]:=k;

            now:=k;

          end;

    end;

  ans:=;

  for i:= to n do

    begin

      fillchar(a,sizeof(a),);

      j:=f[i]; num:=;

      while j> do

        begin

          inc(num);

          a[num]:=j mod ;

          j:=j div ;

        end;

      now:=; sum:=;

      for j:=m downto  do

        if T[now].next[-a[j]]<> then

          begin

            sum:=sum*+-a[j];

            now:=T[now].next[-a[j]];

          end

        else

          begin

            sum:=sum*+a[j];

            now:=T[now].next[a[j]];

          end;

      if sum xor f[i]>ans then ans:=sum xor f[i];

    end;

  writeln(ans);

end.