/*

小包最近迷上了一款叫做雀魂的麻将游戏，但是这个游戏规则太复杂，小包玩了几个月了还是输多赢少。

于是生气的小包根据游戏简化了一下规则发明了一种新的麻将，只留下一种花色，并且去除了一些特殊和牌方式（例如七对子等），具体的规则如下：

总共有36张牌，每张牌是1~9。每个数字4张牌。
你手里有其中的14张牌，如果这14张牌满足如下条件，即算作和牌
14张牌中有2张相同数字的牌，称为雀头。
除去上述2张牌，剩下12张牌可以组成4个顺子或刻子。顺子的意思是递增的连续3个数字牌（例如234,567等），刻子的意思是相同数字的3个数字牌（例如111,777）

例如：
1 1 1 2 2 2 6 6 6 7 7 7 9 9 可以组成1,2,6,7的4个刻子和9的雀头，可以和牌
1 1 1 1 2 2 3 3 5 6 7 7 8 9 用1做雀头，组123,123,567,789的四个顺子，可以和牌
1 1 1 2 2 2 3 3 3 5 6 7 7 9 无论用1 2 3 7哪个做雀头，都无法组成和牌的条件。

现在，小包从36张牌中抽取了13张牌，他想知道在剩下的23张牌中，再取一张牌，取到哪几种数字牌可以和牌。

*/

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {
    public static void main(String[] args){

        Scanner sc=new Scanner(System.in);
        while(sc.hasNextLine()){

            String[] str=sc.nextLine().split(" ");
            int[] nums=new int[13];
            for (int i = 0; i <13 ; i++) {
                nums[i]=Integer.valueOf(str[i]);
            }
            int[] backet=new int[9];
            int[] helper=new int[9];

            for (int i = 0; i <13 ; i++) {
                int num=nums[i];
                backet[num-1]++;
            }


            List<Integer> res=new ArrayList<Integer>();

            for (int i = 0; i <9 ; i++) {
                if(backet[i]<4){
                    int num=i+1;
                    System.arraycopy(backet,0,helper,0,9);
                    //抽一张牌
                    helper[i]++;
                    if(canHu(helper,14,false)) res.add(num);
                }
            }

           if(res.isEmpty()){
               System.out.println(0);
           }else{
               StringBuilder sb=new StringBuilder();
               sb.append(res.get(0));
               for (int i =1; i <res.size() ; i++) {
                   sb.append(" ");
                   sb.append(res.get(i));
               }
               System.out.println(sb.toString());
           }
        }
    }


    private static boolean canHu(int[] helper,int total,boolean hasHead){
        //能不能胡的最核心的指标是，是否可以将所14张牌匹配的剩下0张，并不关注谁做雀头，谁配顺子，谁配刻子
        //至于具体如何匹配，需要尝试，需要回溯，需要按照2条规则去匹配
        if(total==0) return true;

        //因为要胡，必须有雀头，刻子或者顺子可有可无，所以确定雀头,只有确定了雀头，才能继续匹配
        if(!hasHead){
            for (int i = 0; i <9 ; i++) {
                if(helper[i]>=2){ //大于等于2才可以做雀头
                    helper[i]-=2;
                    if(canHu(helper,total-2,true)) return true;
                    helper[i]+=2;
                }
            }
            //如果没有雀头，直接返回false;
            return false;
        }else{
            //已经与有雀头了，因此按照配顺子和配刻子的规则配
            for (int i = 0; i <9 ; i++) {
                if(helper[i]>0){

                    if(helper[i]>=3){  //够三个时考虑配刻子
                        helper[i]-=3;
                        if(canHu(helper,total-3,hasHead)) return true;
                        helper[i]+=3;
                    }

                    //以helper[i]开头配顺子，此处只关心以谁开头，因此所有可能的牌都要遍历
                    if(i+2<9 && helper[i+1]>0 && helper[i+2]>0){
                        helper[i]--;
                        helper[i+1]--;
                        helper[i+2]--;
                        if(canHu(helper,total-3,hasHead)) return true;
                        helper[i]++;
                        helper[i+1]++;
                        helper[i+2]++;
                    }
                }
            }
        }
        return false;
    }
}