// Complete the bfs function below.
   static int[] bfs(int n, int m, int[][] edges, int s) {

      Queue<Integer> q = new LinkedList();
        HashMap<Integer, Integer> visited = new HashMap();
        HashMap<Integer, Integer> results = new HashMap();
       int[] finalResults = new int[n-1];
       int[] levels = new int[n + 1];
        q.add(s);
       levels[s]= 0;
      // System.out.println("n = " + n );

        for(int i = 1; i <= n; i++){
            if(s!=i)
            results.put(i, -1);
        }
        for (Map.Entry<Integer, Integer> entry : results.entrySet()) {
    //   System.out.println(entry.getKey() + " : " + entry.getValue());
           //   finalResults[count++] = entry.getValue();


    // ...
}
        while(!q.isEmpty()) {

            int current = q.remove();
           // visited.add(current);
            // HashMap<Integer, Integer> list = new HashMap();
            Queue<Integer> list = new LinkedList();
            for(int i = 0; i < edges.length; i++) {
               if(edges[i][0] == current)
                   list.add(edges[i][1]);
               // System.out.println("list["+i+"]" + " =" +list[i]);
            }


             //System.out.println("current" + " =" +current);
            int i = 0;
            while(!list.isEmpty()){


                if(!visited.containsValue(list.peek())) {
                    int c = list.remove();
                        levels[c] = levels[current] + 1;
                   // System.out.println("list " + list[i]);
                        if(levels[c] != 0){

                        results.put(c,(6*levels[c]));

                        }else{
                             results.put(c,6);
                        }
                    visited.put(i++,c);
                        q.add(c);
                }



        }
       int count = 0;
      for (Map.Entry<Integer, Integer> entry : results.entrySet()) {
    //   System.out.println(entry.getKey() + " : " + entry.getValue());
              finalResults[count++] = entry.getValue();


    // ...
}



        // for(int i = 0; i<= n; i++ ) {
        //     if(!results.containsKey(i)) finalResults[i - s - 1] = -1;
        //     else finalResults[i - s - 1] = results.get(i);
        // }
        }
        return finalResults;


   }