#include <cstring>

 #include <cstdio>

 #include <vector>

 #include <queue>

 #include <algorithm>

 #include <iostream>

 using namespace std;

 const int maxn =  + , INF = ;

 struct Edge

 {

     int from, to, cap, flow, cost;

 };

 struct MCMF

 {

     int n, m;

     vector<Edge> edges;

     vector<int> G[maxn];

     bool inq[maxn];         // 是否在队列中

     int d[maxn];           // Bellman-Ford

     int p[maxn];           // 上一条弧

     int a[maxn];           // 可改进量

     void init(int n)

     {

         this->n = n;

         for(int i = ; i < n; i++) G[i].clear();

         edges.clear();

     }

     void AddEdge(int from, int to, int cap, int cost)

     {

         edges.push_back((Edge)

         {

             from, to, cap, , cost

         });

         edges.push_back((Edge)

         {

             to, from, , , -cost

         });

         m = edges.size();

         G[from].push_back(m-);

         G[to].push_back(m-);

     }

     bool BellmanFord(int s, int t, int &flow, long long& cost)

     {

         memset(inq,,sizeof(inq));

         for(int i=;i<n;i++)

             d[i] = INF;

         d[s] = ;

         inq[s] = true;

         p[s] = ;

         a[s] = INF;

         queue<int> Q;

         Q.push(s);

         while(!Q.empty())

         {

             int u = Q.front();

             Q.pop();

             inq[u] = false;

             for(int i = ; i < G[u].size(); i++)

             {

                 Edge& e = edges[G[u][i]];

                 if(e.cap > e.flow && d[e.to] > d[u] + e.cost)

                 {

                     d[e.to] = d[u] + e.cost;

                     p[e.to] = G[u][i];

                     a[e.to] = min(a[u], e.cap - e.flow);

                     if(!inq[e.to])

                     {

                         Q.push(e.to);

                         inq[e.to] = true;

                     }

                 }

             }

         }

         if(d[t] == INF) return false; //s-t 不连通，失败退出

         flow += a[t];

         cost += (long long)d[t] * (long long)a[t];

         int u = t;

         while(u != s)

         {

             edges[p[u]].flow += a[t];

             edges[p[u]^].flow -= a[t];

             u = edges[p[u]].from;

         }

         return true;

     }

      pair<long long,int>Mincost(int s, int t)

     {

         long long cost = ;

         int flow = ;

         while(BellmanFord(s, t, flow, cost));

         return pair<long long ,int>{cost,flow};

     }

 };

 MCMF solver;

 int n;

 int main()

 {

     while(true)

     {

         scanf("%d", &n);

         if(n == ) break;

         solver.init(n + );

         int m, from, to, cost;

         scanf("%d", &m);

         for(int i = ; i < m; i++)

         {

             scanf("%d%d%d", &from, &to, &cost);

             solver.AddEdge(from, to, , cost);

             solver.AddEdge(to, from, , cost);

         }

         solver.AddEdge(, , , );

         pair<long long,int> ans = solver.Mincost(, n);

         int flow = ans.second;

         if(flow != )

             puts("Back to jail");

         else

             printf("%lld\n", ans.first);

     }

     return ;

 }