// Finding Nemo solution
//
// The general approach was to build a list of the explosion coordinates and
// then test each fish to see if it was killed or not.  Another approach
// might be to build a list of fish and then test each piece of dynamite
// to see which fish were killed.  However, the ordering of the input for
// the data sets lists the dynamite first, so the first approach is easier.
//
// Also, one mathematical shortcut was used when determining if a fish was
// hit.  Since the explosions and fish each occur only at positions with
// whole number coordinates, a "hit" only happens when an explosion and a
// fish share coordinates that differ in at most one position by at most one.
// Any other scenario would result in a distance of at least sqrt(2), which
// is greater than one. As a shortcut, I simply total the absolute value of
// the differences between the coordinates of the fish and each explosion.  If
// this number is 1 or 0, then the fish is hit, otherwise we go to the next
// explosion.
//

import java.io.*;

class point {
  public int x,y,z;
}

public class FindingNemo {

  static final int MAX_EXPLOSIVES = 10;
  static final int MAX_FISH = 15;

  public static void main(String[] args)
  throws IOException {

    // We need a string tokenizer
    Reader r = new BufferedReader(new InputStreamReader(System.in));
    StreamTokenizer InputTokenizer = new StreamTokenizer(r);
    InputTokenizer.eolIsSignificant(true);   // EOL is important
    InputTokenizer.whitespaceChars(',',','); // Ignore commas

    // The main section loops once for each data set
    // It stops when EOF is reached
    while (true) {

      int token_type;
      int length=0, width=0, depth=0;

      //////////////////
      // Read START line
      //////////////////
      token_type = InputTokenizer.nextToken();

      // If we hit EOF here, then we're done
      // Otherwise, we've read a "START" token
      if (token_type == StreamTokenizer.TT_EOF) break;

      // Get the L,W,D
      for (int i = 0; i < 3; i++) {
        InputTokenizer.nextToken();
        switch (i) {
          case 0: length = (int) InputTokenizer.nval;
          case 1: width = (int) InputTokenizer.nval;
          case 2: depth = (int) InputTokenizer.nval;
        }
      }

      // Get the EOL
      InputTokenizer.nextToken();

      /////////////////////
      // Read dynamite list
      /////////////////////
      int dynamite_index = 0;
      point dynamite_loc[] = new point[MAX_EXPLOSIVES];

      // Note that this for loop has no terminating condition.
      // It is not necessary since we break when we hit EOL.
      for (dynamite_index = 0;; dynamite_index++) {

        token_type = InputTokenizer.nextToken();

        // Break out when we hit EOL
        if (token_type == StreamTokenizer.TT_EOL) break;

        // Read the info
        // Here, I'm using the convention x = length coordinate
        //                                y = width coordinate
        //                                z = depth
        // This was alluded to in the problem statement
        dynamite_loc[dynamite_index] = new point();
        dynamite_loc[dynamite_index].x = (int) InputTokenizer.nval;
        InputTokenizer.nextToken();
        dynamite_loc[dynamite_index].y = (int) InputTokenizer.nval;
        InputTokenizer.nextToken();
        dynamite_loc[dynamite_index].z = (int) InputTokenizer.nval;
        if (dynamite_loc[dynamite_index].z > (int) depth) {
           dynamite_loc[dynamite_index].z = (int) depth;

        }
      }

      /////////////////////////////////////////////
      // Process fish list (see which ones are hit)
      /////////////////////////////////////////////
      int num_fish_hit = 0;
      point fish_loc = new point();

      // Again, we'll exit the loop when we hit EOL or EOF
      for (;;) {
        token_type = InputTokenizer.nextToken();

        // Break out when we hit EOL or EOF
        if (token_type == StreamTokenizer.TT_EOL ||
            token_type == StreamTokenizer.TT_EOF) {
           break;
        }

        // Read the fish location
        fish_loc.x = (int) InputTokenizer.nval;
        InputTokenizer.nextToken();
        fish_loc.y = (int) InputTokenizer.nval;
        InputTokenizer.nextToken();
        fish_loc.z = (int) InputTokenizer.nval;

        // See if this fish was hit
        // Since a fish is hit only if it is within one unit of a detonation
        // and all coordinates are integers, we know that a fish is only killed
        // by a particular piece of dynamite if it is in one of seven possible
        // locations: co-located with the explosion or just above/below or to
        // the side. Being diagonally adjacent isn't close enough because then
        // the distance is sqrt(2) > 1. So we use a shortcut method here that
        // simply totals the differences in the coordinate components between
        // dynamite and fish.  If it is 1 or less, we have a hit; otherwise it
        // is a miss.
        boolean fish_hit = false;
        for (int i = 0; i < dynamite_index; i++) {
          int offset = 0;
          offset = Math.abs(fish_loc.x - dynamite_loc[i].x) +
                   Math.abs(fish_loc.y - dynamite_loc[i].y) +
                   Math.abs(fish_loc.z - dynamite_loc[i].z);
          if (offset <= 1) fish_hit = true;
        }
        if (fish_hit) num_fish_hit++;
      }

      //////////////////
      // Read END line
      //////////////////
      token_type = InputTokenizer.nextToken();
      // Get the EOL or EOF
      InputTokenizer.nextToken();

      /////////////////////
      // Output the results
      /////////////////////
      if (num_fish_hit > 0) {
        System.out.println("AIEE, I got " + num_fish_hit + " fish, me!");
      }
      else {
        System.out.println("None of dem fish blowed up!");
      }
    }
  }
}