#include <iostream>
#include <algorithm>
#include <string>
#include <array>
#include <set>
#include <vector>
#include <cassert>

using namespace std;

struct compare_length {
    inline bool operator()(const std::string& first,
            const std::string& second) const
    {
        return first.size() < second.size();
    }
};

struct Note
{
    array<string,10> patterns;
    array<string,4> outputs;
    
    friend istream &operator>>( istream  &input, Note &n ) { 
        for(int i = 0; i < 10; i++)
        {
            input >> n.patterns[i];
            sort(n.patterns[i].begin(), n.patterns[i].end());
        }
        compare_length c;
        sort(n.patterns.begin(), n.patterns.end(), c);
        sort(n.patterns.begin()+3,n.patterns.begin()+6);
        sort(n.patterns.begin()+6,n.patterns.begin()+9);
        for(int i = 0; i < 4; i++)
        {
            input >> n.outputs[i];
            sort(n.outputs[i].begin(), n.outputs[i].end());
        }
        return input;
    }
};

int main()
{
    Note note;
    int result = 0;
    for(int total_count = 0; total_count < 200; total_count++)
    {
        cin >> note;
        int pattern_map[10] = {1,7,4,9,9,9,9,9,9,8};
        vector<set<char>> pattern_sets(note.patterns.size());
        for(int i = 0; i < note.patterns.size(); i++)
        {
            set<char> cur_set;
            for(int j = 0; j < note.patterns[i].size(); j++)
            {
                cur_set.insert(note.patterns[i][j]);
            }
            pattern_sets[i] = cur_set;
        }
        
        set<char> top = pattern_sets[1];
        for(set<char>::iterator it = pattern_sets[0].begin(); it != pattern_sets[0].end(); ++it) top.erase(*it);

        set<char> middle = pattern_sets[2];
        for(set<char>::iterator it = pattern_sets[0].begin(); it != pattern_sets[0].end(); ++it) middle.erase(*it);
        set<char> left_top = middle;
        for(set<char>::iterator it = middle.begin(); it != middle.end(); ++it)
        {
            while (middle.end() != it && (pattern_sets[3].end() == pattern_sets[3].find(*it) ||
                pattern_sets[4].end() == pattern_sets[4].find(*it) ||
                pattern_sets[5].end() == pattern_sets[5].find(*it)))
            {
                it = middle.erase(it);
            }
        }
        left_top.erase(*middle.begin());
        
        set<char> bottom = pattern_sets[9];
        for(set<char>::iterator it = pattern_sets[1].begin(); it != pattern_sets[1].end(); ++it) bottom.erase(*it);
        for(set<char>::iterator it = pattern_sets[2].begin(); it != pattern_sets[2].end(); ++it) bottom.erase(*it);
        
        set<char> left_bottom = bottom;
        
        for(set<char>::iterator it = bottom.begin(); it != bottom.end(); ++it)
        {
            while (bottom.end() != it && (pattern_sets[3].end() == pattern_sets[3].find(*it) ||
                pattern_sets[4].end() == pattern_sets[4].find(*it) ||
                pattern_sets[5].end() == pattern_sets[5].find(*it)))
            {
                it = bottom.erase(it);
            }
        }
        
        left_bottom.erase(*bottom.begin());
        
        set<char> x;
        for(int i = 6; i <= 8; i++)
        {
            if (pattern_sets[i].find(*middle.begin()) != pattern_sets[i].end() &&
                pattern_sets[i].find(*left_bottom.begin()) != pattern_sets[i].end())
            {
                x = pattern_sets[i];
                break;   
            }
        }

        set<char> right_top = pattern_sets[0];
        for(set<char>::iterator it = x.begin(); it != x.end(); ++it)
            right_top.erase(*it);

        set<char> right_bottom = pattern_sets[0];
        right_bottom.erase(*right_top.begin());

        string zero = "";
        zero.append(1,*top.begin());
        zero.append(1,*left_top.begin());
        zero.append(1,*right_top.begin());
        zero.append(1,*left_bottom.begin());
        zero.append(1,*right_bottom.begin());
        zero.append(1,*bottom.begin());

        sort(zero.begin(),zero.end());

        for(int i = 6; i <= 8; i++)
        {
            if (zero.compare(note.patterns[i]) == 0)
            {
                pattern_map[i] = 0;
            }
        }

        string two = "";
        two.append(1,*top.begin());
        two.append(1,*right_top.begin());
        two.append(1,*middle.begin());
        two.append(1,*left_bottom.begin());
        two.append(1,*bottom.begin());

        sort(two.begin(), two.end());

        for(int i = 3; i <= 5; i++)
        {
            if (two.compare(note.patterns[i]) == 0)
            {
                pattern_map[i] = 2;
            }
        }

        string three = "";
        three.append(1,*top.begin());
        three.append(1,*right_top.begin());
        three.append(1,*middle.begin());
        three.append(1,*right_bottom.begin());
        three.append(1,*bottom.begin());

        sort(three.begin(), three.end());

        for(int i = 3; i <= 5; i++)
        {
            if (three.compare(note.patterns[i]) == 0)
            {
                pattern_map[i] = 3;
            }
        }

        string five = "";
        five.append(1,*top.begin());
        five.append(1,*left_top.begin());
        five.append(1,*middle.begin());
        five.append(1,*right_bottom.begin());
        five.append(1,*bottom.begin());

        sort(five.begin(), five.end());

        for(int i = 3; i <= 5; i++)
        {
            if (five.compare(note.patterns[i]) == 0)
            {
                pattern_map[i] = 5;
            }
        }

        string six = "";
        six.append(1,*top.begin());
        six.append(1,*left_top.begin());
        six.append(1,*middle.begin());
        six.append(1,*right_bottom.begin());
        six.append(1,*left_bottom.begin());
        six.append(1,*bottom.begin());

        sort(six.begin(), six.end());

        for(int i = 6; i <= 8; i++)
        {
            if (six.compare(note.patterns[i]) == 0)
            {
                pattern_map[i] = 6;
            }
        }

        for(int i = 0; i < 10; i++)
        {
            bool found = false;
            for(int j = 0; j < 10; j++)
            {
                if (pattern_map[j] == i)
                {
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                cout << total_count << endl;
            }
        }
        
        for(int i = 0, m = 1000; i < 4; i++, m/=10)
        {
            for(int j = 0; j < 10; j++)
            {
                if (0 == note.outputs[i].compare(note.patterns[j]))
                {
                    result += m*pattern_map[j];
                    break;
                }
            }
        }
    }
    
    cout << result << endl;
    
    return 0;
}