/* Subject: Contest submission for problem #3, file 3.c */
/* cs169-ta@imail.EECS.Berkeley.EDU */
/* Fri Sep 19 01:41:44 PDT 2003 */
/*___CONTEST_SUBMISSION___ cs169-ta 3 */
/*
John Han
Estimated Time : 2 Hours
Actual Time : 4 Hours
Comments : Likely not the most graceful solution ...
*/
#include <contest.h>

struct edge{
  int node1;
  int node2;
  int weight;
};

struct node{
  int name;
  int predecessor;
  int weight;
};

struct edge newEdge(int node1, int node2, int weight){
  struct edge temp;
  temp.node1= node1;
  temp.node2= node2;
  temp.weight= weight;
  return temp;
}

struct node newNode(int name, int predecessor, int weight){
  struct node temp;
  temp.name = name;
  temp.predecessor = predecessor;
  temp.weight = '0';
  return temp;
}

struct node getNode(int name, struct node nodes[], int size){
  int i;
  for (i=0; i<=size; i++){
    if (nodes[i].name == name){
      return nodes[i];
    }
  }
  return newNode(-1, -1, 0);
}

int getNodeIndex(int name, int weight, struct node nodes[], int size){
  int i;
  for (i=0; i<size; i++)
    if ((nodes[i].name == name) && (nodes[i].weight == weight))
      return i;
  return -1;
}

int equal(struct node temp[], struct node temp1[], int size){
  int i;
  for(i=0;i<size;i++)
    if ( (temp[i].name != temp1[i].name) || (temp[i].predecessor != temp1[i].predecessor) || (temp[i].weight != temp1[i].weight) )
      return -1;
  return 1;
}

int contains(int node, struct node nodes[], int size){
  int i;
  for(i=0;i<size;i++){
    if (nodes[i].name == node)
      return 1;
  }
  return -1;
}

int shortPath(char start, char stop, struct edge edges[], int edge_size, struct node nodes[], int node_size, struct node path[]){

  struct node permanent[100];
  struct node temporary[100];
  
  int travel_time=0;
  int path_iter=0;
  int perm_iter=0;
  int temp_iter=0;
  int min_weight=100000;

  char current, predecessor;
  int i=0;
  int j=0;

  current = predecessor = start;

  for(i=0;i<100;i++)
    permanent[i] = temporary[i] = newNode(-1, -1, 0);

  permanent[0]=newNode(start, -1, 0);
  perm_iter = 1;
  while(1){
    for(i=0; i<edge_size; i++){
      if ((current==edges[i].node1)){
	if((edges[i].node2>0)&&(contains(edges[i].node2, permanent, perm_iter) == -1)){

	  temporary[temp_iter].name=edges[i].node2;
	  temporary[temp_iter].predecessor=current;
	  if((j=getNode(current, permanent, perm_iter).weight) > '0')
	    temporary[temp_iter].weight = edges[i].weight - 48 + j;
	  else
	    temporary[temp_iter].weight = edges[i].weight;
	  temp_iter++;
	}
      }

      else if (current==edges[i].node2){
	if(contains(edges[i].node1, permanent, perm_iter) == -1){

	  temporary[temp_iter].name=edges[i].node1;
	  temporary[temp_iter].predecessor=current;

	  if((j=getNode(current, permanent, perm_iter).weight) > '0')
	    temporary[temp_iter].weight = edges[i].weight - 48 + j;
	  else
	    temporary[temp_iter].weight = edges[i].weight;
	  temp_iter++;
	}
      }
    }

    //record the closest from the start in 'permanent'
    for(i=0; i<temp_iter; i++){
      if(temporary[i].weight < min_weight && temporary[i].weight > 0 && temporary[i].name-48 > -1 && contains(temporary[i].name, permanent, perm_iter) == -1){

	permanent[perm_iter] = temporary[i];
	min_weight = temporary[i].weight;
      }
    }
    temporary[getNodeIndex(permanent[perm_iter].name, permanent[perm_iter].weight, temporary, temp_iter)].weight = -1;
    temporary[getNodeIndex(permanent[perm_iter].name, permanent[perm_iter].weight, temporary, temp_iter)].name = -1;

    predecessor=current;
    current=permanent[perm_iter].name;
    
    perm_iter++;
    min_weight = 100000;
   
    if(perm_iter>=node_size)
      break;
  }
  path_iter=-1;

  while(path[path_iter].name!=start){
    path_iter++;
    for (i=perm_iter-1;i>-1;i--){     
      if(permanent[i].name==stop){
    	path[path_iter]=permanent[i];
	travel_time=permanent[i].weight;
	}   //	printf("%i %i\n", stop-48, path[path_iter].name-48);
      
      if(permanent[i].name==path[path_iter-1].predecessor){
	path[path_iter]=permanent[i];
	}
    }
     }
  return travel_time;
}

int main(){

  int i, c, boro, snark, node1, node2, weight, node_size;
  char line[50];
  char statement[100];
  int stat_iter=0;

  struct node path[100];
  struct node subpath[100];
  //  int path_iter=0;
  
  struct node nodes[100];
  int node_iter=0;

  struct edge edges[100];
  int edge_iter=0;


  for(i=0;i<100;i++){
    statement[i]='\0';
    edges[i] = newEdge(-1, -1, -1);
    nodes[i] = newNode(-1, -1, 0);
    path[i] = newNode(-1, -1, 0);
    subpath[i] = newNode(-1, -1, 0);
  }
  gets(line);
  sscanf(line, "%i\n", &node_size);
  
  while ((c=getchar()) != EOF){
    if(c<='9' && c >='0'){
      statement[stat_iter]=c;
      stat_iter++;
    }
  }
  
  i=0;
  edge_iter=0;
  while(statement[i]!='\0'){
    edges[edge_iter]=newEdge(node1=statement[i], node2=statement[i+1], weight=statement[i+2]);
    edge_iter++;
    
    if (contains(node1, nodes, node_iter) == -1){
      nodes[node_iter] = newNode(node1, -1, 0);
      node_iter++;
    }
    if (contains(node2, nodes, node_iter) == -1){
      nodes[node_iter] = newNode(node2, -1, 0);
      node_iter++;
    }

    i+=3;
  }
  
  shortPath('1', '0', edges, edge_iter, nodes, node_iter, path);
  
  i=0;
  while(1){
    if(path[i].name == -1)
      break;
    boro=path[i].weight-48;
    snark=2*(shortPath('2', path[i].name, edges, edge_iter, nodes, node_iter, subpath)-48);

	if (boro > snark){
	      printf("Snark eats\n\n");
	return 1;
	exit(0);
	}
    i++;
  }
  printf("Borogove escapes\n\n");
  return 1;
  exit(0);
}