type

     point=^node;

     node=record

                g,w:longint;

                next:point;

     end;

 var

    i,j,k,l,m,n,tmp,ans,aug,mi,s,t:longint;

    di,a:array[..] of point;

    pre,his,dis,vh:array[..] of longint;

    flag:boolean;p,jl:point;

 function min(x,y:longint):longint;inline;

          begin

               if x<y then  min:=x else min:=y;

          end;

 function add(x,y,z:longint):longint;inline;

           var p:point;

           begin

                new(p);p^.w:=z;p^.g:=y;

                p^.next:=a[x];a[x]:=p;

           end;

 procedure op(x,y,z:longint);inline;

           var p:point;

           begin

                p:=a[x];

                while p<>nil do

                      begin

                           if (p^.g=y) and ((p^.w+z)>=) then

                              begin

                                   p^.w:=p^.w+z;

                                   break;

                              end;

                           p:=p^.next;

                      end;

           end;

 begin

      readln(n,m,s,t);

      for i:= to n do a[i]:=nil;

      for i:= to m do

          begin

               readln(j,k,l);

               add(j,k,l);add(k,j,);

          end;

      for i:= to n do di[i]:=a[i];

      fillchar(dis,sizeof(dis),);

      fillchar(pre,sizeof(pre),);

      fillchar(his,sizeof(his),);

      fillchar(vh,sizeof(vh),);

      i:=s;vh[]:=n;ans:=;aug:=maxlongint;

      while dis[s]<n do

            begin

                 flag:=false;his[i]:=aug;

                 p:=a[i];

                 while p<>nil do

                       begin

                            if (p^.w>) and (dis[i]=(dis[p^.g]+)) then

                               begin

                                    aug:=min(aug,p^.w);

                                    pre[p^.g]:=i;di[i]:=p;

                                    flag:=true;i:=p^.g;

                                    if i=t then

                                       begin

                                            ans:=ans+aug;

                                            while i<>s do

                                                  begin

                                                       tmp:=i;

                                                       i:=pre[i];

                                                       op(i,tmp,-aug);

                                                       op(tmp,i,aug);

                                                  end;

                                            aug:=maxlongint;

                                       end;

                                    break;

                               end;

                            p:=p^.next;

                       end;

                 if flag then continue;

                 jl:=nil;mi:=n-;

                 p:=a[i];

                 while p<>nil do

                       begin

                            if (p^.w>) and (dis[p^.g]<mi) then

                               begin

                                    jl:=p;mi:=dis[p^.g];

                               end;

                            p:=p^.next;

                       end;

                 di[i]:=jl;

                 dec(vh[dis[i]]);

                 if vh[dis[i]]= then break;

                 dis[i]:=mi+;

                 inc(vh[dis[i]]);

                 if i<>s then

                    begin

                         i:=pre[i];

                         aug:=his[i];

                    end;

            end;

      writeln(ans);

 end.