Create a program that reads poker hand data and outputs the role for each. However, this issue follows the rules below.

* Poker is a competition with 5 playing cards.
* No more than 5 cards with the same number.
* There is no joker.
* Suppose you only consider the following poker roles: (The higher the number, the higher the role.)


1. No role (does not apply to any of the following)
2. One pair (two cards with the same number)
3. Two pairs (two pairs of cards with the same number)
4. Three cards (one set of three cards with the same number)
5. Straight (the numbers on 5 cards are consecutive)
However, in the case of a straight containing A, the sequence ending with A is also straight. In other words, there are two types of straights containing A: A 2 3 4 5 and 10 J Q K A. Lines that straddle A, such as J Q K A 2, are not straight. (In this case, it will be "no role").
6. Full House (one set of three cards with the same number and the other two cards with the same number)
7. Four Cards (one set of four cards with the same number)



Input

The input consists of multiple datasets. Each dataset is given in the following format:


Hand 1, Hand 2, Hand 3, Hand 4, Hand 5


In your hand, Trump's J (jack) is 11, Q (queen) is 12, K (king) is 13, A (ace) is 1, and the others are represented by their respective numbers.

The number of datasets does not exceed 50.

Output

For each dataset, output one of the highest roles you can play in your hand. Follow the output example for the notation of the role.

Example

Input

1,2,3,4,1
2,3,2,3,12
12,13,11,12,12
7,6,7,6,7
3,3,2,3,3
6,7,8,9,10
11,12,10,1,13
11,12,13,1,2


Output

one pair
two pair
three card
full house
four card
straight
straight
null
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

    /**
     * 0038 Poker Hand
     */
    public static void main(String[] args) throws IOException {

        // Read All Hands
        List<Hand> hands = readHands();

        for (Hand hand : hands) {
            // Judge a hand
            String handName = hand.judge();

            // Write a result
            System.out.println(handName);
        }
    }

    /**
     * Read all input line and return the list of hand.
     *
     * @return List of Hand
     */
    protected static List<Hand> readHands() throws IOException {

        List<Hand> hands = new ArrayList<Hand>();
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                System.in));

        // One line to one Hand
        String line = null;
        while ((line = reader.readLine()) != null) {

            // Convert line to int array
            String[] values = line.split(",");
            int[] cards = new int[values.length];
            for (int i = 0; i < values.length; i++) {
                cards[i] = Integer.parseInt(values[i]);
            }

            // Create hand and add to list
            hands.add(new Hand(cards));
        }

        if (reader != null) {
            reader.close();
        }

        return hands;
    }

    /**
     * Hand class
     */
    static class Hand {

        /** card array */
        int[] cards;

        /**
         * Constructor
         *
         * @param cards card array
         */
        public Hand(final int[] cards) {
            // Copy arguments to fields
            this.cards = new int[5];
            System.arraycopy(cards, 0, this.cards, 0, cards.length);
        }

        /**
         * Judge this hand.
         *
         * @return Hand name if this hand has some role or null
         */
        public String judge() {

            // Count
            int[] numberOfCards = new int[14]; // A to K (index 0 is not used)
            for (int card : cards) {
                numberOfCards[card]++;
            }

            // Find role elements
            int pair = 0;
            int threeCard = 0;
            int fourCard = 0;
            for (int number : numberOfCards) {
                switch (number) {
                case 2:
                    pair++;
                    break;
                case 3:
                    threeCard++;
                    break;
                case 4:
                    fourCard++;
                    break;
                }
            }

            // Judge "Four Card"
            if (fourCard > 0) {
                return "four card";
            }

            // Judge "Full House"
            if (pair > 0 && threeCard > 0) {
                return "full house";
            }

            // Prepare to judge "Straight"
            int[] straightJudge = new int[5];
            System.arraycopy(cards, 0, straightJudge, 0, cards.length);
            Arrays.sort(straightJudge);

            // Judge "Straight" (is all card is sequantial?)
            int sequenceCount = 0;
            for (int i = 1; i < straightJudge.length; i++) {
                if ((straightJudge[i] - straightJudge[i - 1]) == 1) {
                    sequenceCount++;
                }
            }
            if (sequenceCount == 4) {
                return "straight";
            }

            // Judge "Straight" (is special straight including A)
            if (straightJudge[0] == 1 && straightJudge[1] == 10 && straightJudge[2] == 11 && straightJudge[3] == 12
                    && straightJudge[4] == 13) {
                return "straight";
            }

            // Judge "Three card"
            if (threeCard > 0) {
                return "three card";
            }

            // Judge "Two pair"
            if (pair > 1) {
                return "two pair";
            }

            // Judge "One pair"
            if (pair > 0) {
                return "one pair";
            }
            return null;
        }
    }

}