import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.IOException;

public class Message
{
     private String itsReceiver = null;
     private String itsSubject = null;
     private String itsSender = null;


     /** Create a Message object from the next two lines of the
      *  source file.  Set sender to null at end-of-file. */

     public Message (BufferedReader source) throws IOException
     {    String s = source.readLine();
          if (s != null)
          {    StringTokenizer line = new StringTokenizer (s);
               if (line.hasMoreTokens())
               {    itsSender = line.nextToken();
                    if (line.hasMoreTokens())
                    {    itsReceiver = line.nextToken();
                         itsSubject  = source.readLine();
                    }
               }
          }
     }    //======================


     public String getSender()
     {    return itsSender;
     }    //======================


     public String getReceiver()
     {    return itsReceiver;
     }    //======================


     public String getSubject()
     {    return itsSubject;
     }    //======================
}     

public class EmailSet
{
     public static final int MAX = 50;
     /////////////////////////////////
     private int[][] itsItem = new int[MAX][MAX];  
                    // all components of the array are initially zero
     private int itsSize = 0;     
                    // non-zero entries are indexed 0..itsSize-1
     private int itsNumEmails = 0; // total of all non-zero entries


     /** Return the total number of emails sent. */

     public int getNumEmails()
     {    return itsNumEmails;
     }    //======================


     /** Return the total number of employees sending email. */

     public int getNumEmployees()
     {    return itsSize;
     }    //======================


     /** Return the number of emails sent from from to to. */

     public int numSent (int from, int to)
     {    return itsItem[from][to];
     }    //======================


     /** Return the number of emails sent to code. */

     public int numSentTo (int code)   // in EmailSet
     {    int count = 0;
          for (int from = 0;  from < itsSize;  from++)
               count += itsItem[from][code];
          return count;
     }    //======================


     /** Return the smallest number of emails that code sent anyone. */

     public int minSentFrom (int code)  // version 1; in EmailSet
     {    int min = itsItem[code][0];
          for (int to = 1;  to < itsSize;  to++)
          {    if (min > itsItem[code][to])
                    min =  itsItem[code][to];
          }
          return min;
     }    //======================


     /** Return the smallest number of emails that code sent anyone. */

     public int minSentFromV2 (int code)  // version 2; in EmailSet
     {    int[] oneRow = itsItem[code];  // name the row, for clarity
          int min = oneRow[0]; 
          for (int to = 1;  to < itsSize;  to++)
          {    if (min > oneRow[to])
                    min = oneRow[to];
          }
          return min;
     }    //======================


     public int codeOfMaxSelfSent()  // in EmailSet
     {    int code = 0;
          for (int k = 1;  k < itsSize;  k++)
          {    if (itsItem[code][code] < itsItem[k][k])
                    code = k;
          }
          return code;
     }    //======================


     public boolean anyMoreThan (int cutoff)  // in EmailSet
     {    for (int from = 0;  from < itsSize;  from++)
          {    for (int to = 0;  to < itsSize;  to++)
               {    if (itsItem[from][to] > cutoff)
                         return true;
               }
          }
          return false;
     }    //======================


     // public class EmailSet continued

     private String[] itsName = new String[MAX];

     /** Add the given message to the set of stored emails. */

     public void add (Message given)
     {    int from = findCode (given.getSender());
          int to = findCode (given.getReceiver());
          itsItem[from][to]++;
          itsNumEmails++;
     }    //======================


     /** Precondition:  0 <= code < getNumEmployees() */

     public String findEmployee (int code)
     {    return itsName[code];
     }    //======================


     /** Return the code for the given employee. */

     private int findCode (String employee)
     {    for (int k = 0;  k < itsSize;  k++)
          {    if (employee.equals (itsName[k]))
                    return k;
          }
          itsName[itsSize] = employee;
          itsSize++;
          return itsSize - 1;
     }    //======================


     /** Return the number of emails that code sent. */

     public int numSentFrom (int code)
     {    int count = 0;
          for (int k = 0;  k < itsSize;  k++)
               count += itsItem[code][k];
          return count;
     }    //======================


     /** Return the largest total number of emails sent by anyone. */

     public int mostSent()
     {    int max = numSentFrom (0);
          for (int k = 1;  k < itsSize;  k++)
          {    if (max < numSentFrom (k))
                    max = numSentFrom (k);
          }
          return max;
     }    //======================


     /** Return the number of people to whom code sent email. */

     public int numPeopleSentBy (int code)  // in EmailSet
     {    int count = 0;
          for (int to = 0;  to < itsSize;  to++)
          {    if (itsItem[code][to] > 0)
                    count++;
          }
          return count;
     }    //======================


     /** Return the largest number of emails sent to code. */

     public int maxSentTo (int code)  // in EmailSet
     {    int max = itsItem[0][code];
          for (int from = 1;  from < itsSize;  from++)
          {    if (max < itsItem[from][code])
                    max =  itsItem[from][code];
          }
          return max;
     }    //======================
}     

import java.io.*;

public class EmailStats 
{
     /** Read one day's email file and print several usage
      *  statistics about it. */

     public static void main (String[] args) throws IOException
     {    
          if (args.length < 2)
               System.out.println ("Specify the two file names");
          else
          {
               // CONSTRUCT THE EMAIL FILE AND THE DATABASE
               BufferedReader inputFile = new BufferedReader
                                         (new FileReader (args[0]));
               EmailSet database = new EmailSet();

               // READ THE EMAIL FILE AND STORE IT IN THE DATABASE
               Message data = new Message (inputFile);
               while (data.getSender() != null)
               {    database.add (data);
                    data = new Message (inputFile);
               }

               // PRINT THE RESULTS TO THE OUTPUT FILE
               if (database.getNumEmployees() > 0)
                    EmailOp.printStatistics (database, new PrintWriter 
                                            (new FileWriter (args[1])));
          }
     }    //======================
}     

class EmailOp   // helper class for Email
{
     /** Print the statistics about email usage. Precondition:
      *  db and out are non-null, and db is not empty. */

     public static void printStatistics (EmailSet db, 
                                         PrintWriter out)
     {    // PRINT OVERALL AVERAGE
          int size = db.getNumEmployees();  // for speed of execution
          out.println (db.getNumEmails() + " email sent by "
                        + size + " people; average sent per person = "
                        + (1.0 * db.getNumEmails()) / size);

          // PRINT THOSE WITH HEAVY IMBALANCE IN SENT VS RECEIVED
          for (int k = 0;  k < size;  k++)
          {    String name = db.findEmployee (k);
               if (db.numSentFrom (k) == 0)
                    out.println (name + " did not send any email.");
               else
               {    double ratio = 1.0 * db.numSentTo (k) 
                                       / db.numSentFrom (k);
                    if (ratio >= 2.0)
                         out.println (name + " received twice the sent.");
                    else if (ratio <= 0.5)
                         out.println (name + " sent twice the received.");
                    if (db.numSent (k, k) > 0)
                         out.println (name + " sent himself email.");
               }
          }

          // PRINT THOSE WHO SENT THE MOST AMOUNT OF EMAIL
          int largest = db.mostSent();
          for (int k = 0;  k < size;  k++)
          {    if (db.numSentFrom (k) == largest)
                    out.println (db.findEmployee (k) + " sent most.");
          }
          out.close();
     }    //======================
}

public class Flight
{
     public final String aircraftType;
     public final double ticketPrice;
     public final int    numSeats; // available unreserved
     public final int    numReservations;
     public final long   filePosition;


     public Flight (String type, double price, int seats, 
                    int reservations, long position)
     {    aircraftType = type;
          ticketPrice = price;
          numSeats = seats;
          numReservations = reservations;
          filePosition = position;
     }    //======================
}

public class FlightSet
{
     public static final int MAX = 20;
     /////////////////////////////////
     private Flight[][] plane = new Flight[MAX][MAX];


     /** Return the fare for the flight with the lowest fare.
      *  However, return any value if there are no flights. */

     public double cheapestFare()
     {    double smallestSoFar = 1000000.0;     // a million dollars
          for (int dep = 0;  dep < MAX;  dep++)
          {    for (int arr = 0;  arr < MAX;  arr++)
               {    if (plane[dep][arr] != null
                           && plane[dep][arr].ticketPrice < smallestSoFar)
                         smallestSoFar = plane[dep][arr].ticketPrice;
               }
          }
          return smallestSoFar;
     }    //======================


     /** Write the information to the appropriate disk-file record. */

     public void writeRecord (Flight flit) throws IOException
     {    raf.seek (flit.filePosition);
          raf.writeChars (flit.aircraftType + "\n");
          raf.writeDouble (flit.ticketPrice);
          raf.writeInt (flit.numSeats);
          raf.writeInt (flit.numReservations);
     }    //======================
}

import java.io.Reader;
import java.io.IOException;

public class Buffy
{
     public static final int MAX = 8192;
     /////////////////////////////////
     private Reader itsInput;        // the file or keyboard input
     private char[] itsBuf;          // chars read but not used
     private int itsSize;            // number of chars stored
     private int itsNextChar;        // position of next char 
     private boolean itsAtEndOfFile; // true when no more to read


     public Buffy (Reader given) throws IOException
     {    itsInput = given;
          itsBuf = new char[MAX];
          fillBufferStartingAt (0); // get the first characters
     }    //======================


     private void fillBufferStartingAt (int loc) throws IOException
     {    itsSize = loc + itsInput.read (itsBuf, loc, MAX - loc);
          itsAtEndOfFile = itsSize < MAX;
          if (itsAtEndOfFile)
               itsInput.close();
          itsNextChar = 0;
     }    //======================


     public String readLine() throws IOException
     {    if (itsNextChar >= itsSize - 2000 && ! itsAtEndOfFile)
               downShiftAndFill();
          if (itsNextChar >= itsSize)         // no more characters
               return null;
          int start = itsNextChar;
          int count = 0;
          while (itsBuf[start + count] != '\n')
               count++;
          itsNextChar = start + count + 1;   // prepare for next call
          return new String (itsBuf, start, count);
     }    //======================


     private void downShiftAndFill() throws IOException
     {    for (int k = itsNextChar;  k < itsSize;  k++)
               itsBuf[k - itsNextChar] = itsBuf[k];
          itsSize -= itsNextChar;
          fillBufferStartingAt (itsSize);
     }    //======================
}     

import java.net.*;
import java.io.*;

public class Telnetting
{
     public static void main (String[] args)
     {    try
          {    Handler birthNames = new Handler();
               ServerSocket server = new ServerSocket (12345, 20);
               for (;;)
               {    Socket client = server.accept();  // blocks
                    BufferedReader input = new BufferedReader 
                      (new InputStreamReader(client.getInputStream()));
                    PrintWriter output = new PrintWriter
                                        (client.getOutputStream());
                    birthNames.getMore (input, output);
                    client.close();
               }
          }catch (IOException e)
          {    System.out.println ("could not open server or socket");
          }
     }    //=======================
}
//############################################################



import java.io.*;

public class Handler
{
     private String itsInfo = "";

     public void getMore (BufferedReader input, PrintWriter output)
     {    try 
          {    if (itsInfo.length() > 0)
                    output.println ("Suggestions so far:" + itsInfo);
               output.println ("What do you suggest for a baby name?");
               output.flush();
               String data = input.readLine();
               while (data != null && data.length() > 0)
               {    itsInfo += " " + data;
                    output.println ("Another suggestion? ENTER to quit");
                    output.flush();
                    data = input.readLine();
               }
               output.close();
          }catch (IOException e)
          {    // no need for any statements here
          }
     }    //=======================
}