[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
create new integer constant INF = 2147483647
define integer constant mod =1000000007
new constant integer tmod = 1000000009
let ma be a map from characters to integers
create new array of integers vis with size 25
declare vector of integers v
declare new array of integers sum with size 25
a1 is an array of integers with 5 elements
create new array of integers a2 with size 5
define the main function
    declare new integer called n
    read variable n from the input
    assign 0 to ma['R']
    change ma['G'] to 1
    assign the new value = 2 to ma['B']
    set ma['Y'] to 3
    assign the new value = 4 to ma['W']
    start for loop from i = 0 to n exclusive
        define string str
        read input to str
        declare new integer tmp = ma[str[0]] * 5 + str[1] - '1'
        change vis[tmp] to 1
    end of the block
    start for loop from i = 0 to 25 exclusive incrementing i
        if vis[i] is true, add i to v
    define integer ans = 10
    in a for loop, change s from 0 to 1 << 10 exclusive
        set the values of first sizeof(a1) bytes at the pointer a1 to 0
        set first sizeof(a2) bytes at the pointer a2 to 0
        change the values of first sizeof(sum) bytes at the pointer sum to 0
        create integer pos with value 1
        for integer i = 0 to 5 exclusive
            if (s >> i) & 1 != 0, change the value of a1[i] to pos and increment pos
        declare integer variable with name pos2 = 1
        for i from 5 to 10 exclusive
            if (s >> i) & 1 != 0, set a2[i % 5] to pos2 and increase pos2 by 1
        for integer i = 0 to (ength of v exclusive
            define integer tmp with value v[i]
            define new integer called l with value = value of a1[tmp / 5]
            new integer r = value of a2[tmp % 5]
            increment sum[l * 5 + r] by one
        end of the block
        create new boolean flag = true
        in a for loop, change i from 0 to 25 exclusive incrementing i
            if sum[i] is greater than 1
                assign the new value = false to flag
                stop the loop
            end of the block
        if flag is false, skip the rest of the loop
        change ans to min of ans and pos - 1 + pos2 - 1
    end of the block
    print ans and '\n'
    return to indicate successful execution
end of the block

[CODE]:

const int INF = 2147483647;
const int mod = 1000000007;
const int tmod = 1000000009;
map<char, int> ma;
int vis[25];
vector<int> v;
int sum[25];
int a1[5];
int a2[5];
int main() {
    int n;
    cin >> n;
    ma['R'] = 0;
    ma['G'] = 1;
    ma['B'] = 2;
    ma['Y'] = 3;
    ma['W'] = 4;
    for (int i = 0; i < (n); i++) {
        string str;
        cin >> str;
        int tmp = ma[str[0]] * 5 + str[1] - '1';
        vis[tmp] = 1;
    }
    for (int i = 0; i < (25); i++)
        if (vis[i]) v.push_back(i);
    int ans = 10;
    for (int s = 0; s < (1 << 10); s++) {
        memset(a1, 0, sizeof(a1));
        memset(a2, 0, sizeof(a2));
        memset(sum, 0, sizeof(sum));
        int pos = 1;
        for (int i = 0; i < 5; i++)
            if ((s >> i) & 1) a1[i] = pos++;
        int pos2 = 1;
        for (int i = 5; i < 10; i++)
            if ((s >> i) & 1) a2[i % 5] = pos2++;
        for (int i = 0; i < (v.size()); i++) {
            int tmp = v[i];
            int l = a1[tmp / 5];
            int r = a2[tmp % 5];
            sum[l * 5 + r]++;
        }
        bool flag = true;
        for (int i = 0; i < (25); i++)
            if (sum[i] > 1) {
                flag = false;
                break;
            }
        if (!flag) continue;
        ans = min(ans, pos - 1 + pos2 - 1);
    }
    cout << ans << '\n';
    return 0;
}

W4 Y1 W5 R4 W3 Y1 R4 W2 G3 G1 B5 Y5 Y2 Y3 G4 B5 W1 G5 Y5 Y3 G2 Y5 Y5 G5 R2 B3 B1 W5 Y1 W5 B4 W4 R4 B1 R1 W3 R5 R4 G2 W3 W3 R2 W5 Y2 B2 R3 R3 Y1 G5 G2 Y1 R4 Y5 W5 G5 B3 W2 R1 B2 W2 W2 Y5 W3 G1 B1 G2 Y3 W3 G1 W5 W1 G5 G2 Y1 W5 B5 W4 Y5 G2 R3 B4 R5 B1 R1 B4 Y4 Y4 Y3 R5 Y3 B3 W5 R5 Y5 G2 G5 W5 B4 G4 W5

B5 G3 Y2 W3 W1 G1 Y4 G3 G4 B5 W4 B5 Y3 R5 B4 G4 G4 B1 G1 R5 G4 B4 G1 G2 W1 Y4 R5 Y3 W5 W4 Y5 W1 B4 G3 R2 R3 W1 B4 Y4 G2 G2 R1 Y5 W1 Y3 B3 G5 Y3 G3 W2 W5 Y4 B2 Y5 R4 B2 Y3 W4 G2 G3 R2 W1 B4 B2 B1 Y2 Y2 Y3 W3 Y5 W1 R1 R1 R4 R4 R4 Y1 Y3 B2 Y3 Y1 R3 G4 G4 Y5 B5 W2 G1 G5 B3 G1 Y1 R2 G5 R2 Y5 R5 Y4 R4 W2

Y3 Y3 Y5 Y2 Y4 Y1 Y2 Y3 Y1 Y5 Y3 Y1 Y4 Y5 Y5 Y3 Y1 Y5 Y2 Y3 Y1 Y4 Y4 Y1 Y2 Y2 Y4 Y2 Y4 Y5 Y5 Y2 Y3 Y1 Y3 Y5 Y3 Y1 Y5 Y3 Y3 Y2 Y5 Y1 Y5 Y5 Y4 Y2 Y2 Y1 Y2 Y4 Y3 Y2 Y5 Y3 Y4 Y3 Y1 Y4 Y2 Y4 Y4 Y3 Y3 Y1 Y1 Y4 Y2 Y5 Y3 Y4 Y4 Y4 Y3 Y2 Y2 Y2 Y3 Y4 Y4 Y2 Y1 Y2 Y2 Y4 Y3 Y5 Y4 Y2 Y5 Y3 Y1 Y5 Y2 Y5 Y4 Y1 Y2 Y1

G3 B3 G3 Y3 R3 G3 R3 G3 W3 B3 B3 B3 R3 Y3 Y3 W3 R3 B3 G3 W3 G3 W3 Y3 R3 Y3 W3 W3 G3 W3 G3 W3 Y3 G3 R3 Y3 W3 W3 Y3 Y3 Y3 R3 W3 R3 G3 W3 W3 G3 Y3 B3 W3 B3 Y3 G3 Y3 B3 Y3 W3 Y3 R3 Y3 R3 W3 W3 W3 G3 Y3 G3 R3 B3 R3 Y3 R3 Y3 R3 Y3 R3 Y3 R3 W3 Y3 R3 W3 W3 W3 G3 G3 Y3 B3 Y3 R3 G3 G3 B3 B3 Y3 R3 G3 R3 W3 G3

W5 Y5 Y3 W3 Y5 Y5 W5 W5 Y3 W5 Y5 Y3 W5 Y5 W5 W3 Y3 Y5 W3 W5 Y5 W3 Y5 Y3 W3 W3 Y3 Y5 W3 W3 Y3 Y5 W3 Y5 Y5 Y5 W5 Y5 W5 Y5 W5 W5 W3 W5 W3 Y3 W5 W3 W3 W5 Y3 Y5 W5 W5 W3 W5 W5 Y5 W5 W3 W3 W3 Y3 Y5 Y5 Y3 Y5 W5 W5 Y5 W3 W3 W5 Y5 Y5 Y3 W5 W5 W3 Y5 W3 W5 Y3 Y5 W5 Y3 Y3 W3 Y3 Y5 Y3 Y3 W5 Y5 Y3 Y5 Y3 W3 Y3 W5

Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y5 Y5 Y3 Y3 Y5 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5

Y3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 Y3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3

G5 G5 G3 G2 G3 Y3 W3 Y3 G5 W5 G2 G2 W5 G5 G5 W3 G3 G2 Y3 W5 W3 G5 W5 G2 Y2 Y3 W5 G3 W3 W2 G2 W3 Y2 G3 G3

G3 G2 G5 G2 W2 G3 W2 W5 Y5 G5 W2 W2 W2 G5 Y2 G5 W5 W3 W2 Y2 G5 W5 W3 W5 Y2 Y5 W2 W2 W3 Y3 G2 W3 G5 G3 W2

W2 W3 Y2 G5 G2 W3 G5 Y2 W5 Y5 W3 G2 G3 W5 W2 W3 Y2 Y5 Y2 Y5 Y2 Y2 G2 Y5 W3 Y5 G3 Y2 G3 Y2 Y5 W5 G3 W5 W5

Y2 Y3 Y2 Y3 Y5 Y5 Y3 Y5 Y5 Y2 Y2 Y5 Y2 Y2 Y5 Y3 Y2 Y5 Y5 Y3 Y3 Y2 Y2 Y2 Y3 Y5 Y2 Y5 Y5 Y3 Y5 Y2 Y3 Y3 Y2

Y5 Y5 W5 Y5 W3 Y3 W5 W3 W5 W3 W5 Y5 Y3 W3 W5 W5 W5 W3 Y5 Y3 Y5 W5 W5 Y3 Y5 Y5 Y3 W5 W3 W3 W3 W5 Y5 W3 W5

G3 G3 W3 W3 G3 G3 Y3 G3 Y3 Y3 G3 W3 Y3 G3 W3 Y3 W3 Y3 Y3 Y3 Y3 G3 G3 Y3 Y3 G3 G3 G3 G3 G3 Y3 W3 W3 W3 G3

R2 R2 R2 R2 G3 G2 Y3 G2 R3 W5 G4 Y3 Y3 G2 Y5 W5 G4 G2 W4 Y2 W3 R5 W5 G4 G4 Y2 G2 Y5 G2 Y4 W3 G5 G2 R3 G4

G2 Y1 Y1 R4 G5 B5 R2 G4 G2 G3 W4 W1 B3 W5 R2 Y5 R4 R4 B5 Y2 B4 B1 R3 G4 Y3 G2 R4 G3 B2 G2 R3 B2 R1 W2 B4

W4 Y5 Y3 Y3 R5 W3 R5 W2 R5 Y2 R2 Y2 G2 G3 Y4 Y4 R4 Y3 G2 W2 R2 R3 Y3 W5 W2 G4 R3 R3 W2 W5 Y4 R3 W2 R4 R2

Y3 Y3 Y3 Y3 Y3 Y3 W3 G3 G3 G3 W3 G3 G3 Y3 Y3 W3 G3 G3 Y3 W3 W3 Y3 Y3 G3 W3 W3 G3 Y3 Y3 W3 G3 W3 G3 W3 G3

W3 Y3 W3 W5 Y5 W3 W3 Y5 W3 W3 W3 W5 W3 Y3 Y5 Y3 Y5 Y3 W3 W3 W5 W5 W3 Y5 W3 W3 Y3 W3 W5 W3 Y3 Y3 Y5 Y5 Y3

Y3 R2 R2 Y2 Y5 Y4 B3 B3 Y4 W3 R1 W3 W5 B5 R1 Y4 B4 B5 B3 G3 B1 R2 R4 G5 Y5

W5 R1 Y3 G5 G3 G5 W2 Y1 R3 R4 B3 G5 G2 Y2 W1 G2 Y1 B4 Y2 G3 G3 Y4 W3 W5 Y2

Y1 W2 G3 W1 G1 G3 G4 W1 B2 W3 R4 B1 G2 Y4 G1 R2 R3 Y4 B2 G4 W2 Y2 R2 Y5 R4

B3 Y1 R3 Y3 R5 B4 B3 G1 R1 B4 B5 W3 R4 W1 B3 Y3 B3 Y4 B2 G5 Y1 G5 R4 B5 Y1

G4 R4 Y1 Y4 R3 B5 W2 G4 B5 B2 G1 B4 R4 G2 Y3 Y4 G5 Y3 R1 G2 Y5 G3 Y3 Y4 W3

R1 R3 G1 B5 Y5 W3 R4 R4 R1 G3 R2 W1 B1 G2 W2 G4 R2 W3 B1 W3 B5 Y5 R2 B4 B5

Y3 R4 G1 W1 R3 R2 W4 W1 R5 Y4 G3 R5 Y2 W1 Y1


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
define arrays of shorts X and Y with size 105
bin is a new array of shorts with size 15
create constant integer variable C with value 5
create a map from characters to integers called M
void function trans with int argument x
    create new integer variable ind with value 0
    set first 12 elements of bin to 0
    while x > 0
        change the value of bin[ind] to x modulo 2 and increment ind
        change the value of s quared divided by 2
    end of the block
end of the block
define the main function
    create new character called ch
    define new integer n
    read n from the user input
    assign 0 to M['R']
    assign 1 to M['G']
    change the value of M['B'] to 2
    assign 3 to M['Y']
    assign the new value = 4 to M['W']
    for i = 0 to n exclusive
        read standard input to ch
        change the value of X[i] to M[ch]
        read ch
        assign the new value = ch - '1' to Y[i]
    end of the block
    define integers ans and anst with ans = 20
    declare boolean variable all
    new boolean ones = true
    start for loop from i = 0 to n - 1 exclusive, change ones to (X[i] == X[i + 1] && Y[i] == Y[i + 1]) && ones
    if ones is false
        for integer i = 1 to 1023 inclusive incrementing i
            call trans of i
            change the value of anst to 0
            assign the new value = true to all
            increment k in a loop from 0 to n - 1 exclusive
                for integer l = k + 1 to n exclusive
                    if X[k] != X[l] and (bin[X[k]] or bin[X[l]] = 1)
                        change the value of all to true
                    else if Y[k] != Y[l] and (bin[Y[k] + C] or bin[Y[l] + C] = 1)
                        change the value of all to true
                    else if X[l] = X[k] and Y[l] = Y[k]
                        assign true to all
                    else
                        assign false to all
                    if all is false, break
                end of the block
                if all is false, break the loop
            end of the block
            if all is true
                for i = 0 to 12 exclusive
                    if bin[i] is equal to 1, increment anst by one
                change the value of ans to anst of ans > anst
            end of the block
        end of the block
    else
        print 0
    if ones is false, print ans
    return to indicate successful execution
end of the block

[CODE]:

short X[105], Y[105];
short bin[15];
const int C = 5;
map<char, int> M;
void trans(int x) {
    int ind = 0;
    for (int j = 0; j < 12; j++) bin[j] = 0;
    while (x > 0) {
        bin[ind++] = x % 2;
        x /= 2;
    }
}
int main() {
    char ch;
    int n;
    cin >> n;
    M['R'] = 0;
    M['G'] = 1;
    M['B'] = 2;
    M['Y'] = 3;
    M['W'] = 4;
    for (int i = 0; i < n; i++) {
        cin >> ch;
        X[i] = M[ch];
        cin >> ch;
        Y[i] = ch - '1';
    }
    int ans = 20, anst;
    bool all;
    bool ones = true;
    for (int i = 0; i < n - 1; i++) ones = (X[i] == X[i + 1] && Y[i] == Y[i + 1]) && ones;
    if (!ones) {
        for (int i = 1; i <= 1023; i++) {
            trans(i);
            anst = 0;
            all = true;
            for (int k = 0; k < n - 1; k++) {
                for (int l = k + 1; l < n; l++) {
                    if (X[k] != X[l] && ((bin[X[k]] == 1) || (bin[X[l]] == 1)))
                        all = true;
                    else if (Y[k] != Y[l] && ((bin[Y[k] + C] == 1) || bin[Y[l] + C] == 1))
                        all = true;
                    else if (X[l] == X[k] && Y[l] == Y[k])
                        all = true;
                    else
                        all = false;
                    if (!all) break;
                }
                if (!all) break;
            }
            if (all) {
                for (int i = 0; i < 12; i++)
                    if (bin[i] == 1) anst++;
                ans = ans > anst ? anst : ans;
            }
        }
    } else
        cout << 0 << endl;
    if (!ones) cout << ans << endl;
    return 0;
}

W4 Y1 W5 R4 W3 Y1 R4 W2 G3 G1 B5 Y5 Y2 Y3 G4 B5 W1 G5 Y5 Y3 G2 Y5 Y5 G5 R2 B3 B1 W5 Y1 W5 B4 W4 R4 B1 R1 W3 R5 R4 G2 W3 W3 R2 W5 Y2 B2 R3 R3 Y1 G5 G2 Y1 R4 Y5 W5 G5 B3 W2 R1 B2 W2 W2 Y5 W3 G1 B1 G2 Y3 W3 G1 W5 W1 G5 G2 Y1 W5 B5 W4 Y5 G2 R3 B4 R5 B1 R1 B4 Y4 Y4 Y3 R5 Y3 B3 W5 R5 Y5 G2 G5 W5 B4 G4 W5

B5 G3 Y2 W3 W1 G1 Y4 G3 G4 B5 W4 B5 Y3 R5 B4 G4 G4 B1 G1 R5 G4 B4 G1 G2 W1 Y4 R5 Y3 W5 W4 Y5 W1 B4 G3 R2 R3 W1 B4 Y4 G2 G2 R1 Y5 W1 Y3 B3 G5 Y3 G3 W2 W5 Y4 B2 Y5 R4 B2 Y3 W4 G2 G3 R2 W1 B4 B2 B1 Y2 Y2 Y3 W3 Y5 W1 R1 R1 R4 R4 R4 Y1 Y3 B2 Y3 Y1 R3 G4 G4 Y5 B5 W2 G1 G5 B3 G1 Y1 R2 G5 R2 Y5 R5 Y4 R4 W2

Y3 Y3 Y5 Y2 Y4 Y1 Y2 Y3 Y1 Y5 Y3 Y1 Y4 Y5 Y5 Y3 Y1 Y5 Y2 Y3 Y1 Y4 Y4 Y1 Y2 Y2 Y4 Y2 Y4 Y5 Y5 Y2 Y3 Y1 Y3 Y5 Y3 Y1 Y5 Y3 Y3 Y2 Y5 Y1 Y5 Y5 Y4 Y2 Y2 Y1 Y2 Y4 Y3 Y2 Y5 Y3 Y4 Y3 Y1 Y4 Y2 Y4 Y4 Y3 Y3 Y1 Y1 Y4 Y2 Y5 Y3 Y4 Y4 Y4 Y3 Y2 Y2 Y2 Y3 Y4 Y4 Y2 Y1 Y2 Y2 Y4 Y3 Y5 Y4 Y2 Y5 Y3 Y1 Y5 Y2 Y5 Y4 Y1 Y2 Y1

G3 B3 G3 Y3 R3 G3 R3 G3 W3 B3 B3 B3 R3 Y3 Y3 W3 R3 B3 G3 W3 G3 W3 Y3 R3 Y3 W3 W3 G3 W3 G3 W3 Y3 G3 R3 Y3 W3 W3 Y3 Y3 Y3 R3 W3 R3 G3 W3 W3 G3 Y3 B3 W3 B3 Y3 G3 Y3 B3 Y3 W3 Y3 R3 Y3 R3 W3 W3 W3 G3 Y3 G3 R3 B3 R3 Y3 R3 Y3 R3 Y3 R3 Y3 R3 W3 Y3 R3 W3 W3 W3 G3 G3 Y3 B3 Y3 R3 G3 G3 B3 B3 Y3 R3 G3 R3 W3 G3

W5 Y5 Y3 W3 Y5 Y5 W5 W5 Y3 W5 Y5 Y3 W5 Y5 W5 W3 Y3 Y5 W3 W5 Y5 W3 Y5 Y3 W3 W3 Y3 Y5 W3 W3 Y3 Y5 W3 Y5 Y5 Y5 W5 Y5 W5 Y5 W5 W5 W3 W5 W3 Y3 W5 W3 W3 W5 Y3 Y5 W5 W5 W3 W5 W5 Y5 W5 W3 W3 W3 Y3 Y5 Y5 Y3 Y5 W5 W5 Y5 W3 W3 W5 Y5 Y5 Y3 W5 W5 W3 Y5 W3 W5 Y3 Y5 W5 Y3 Y3 W3 Y3 Y5 Y3 Y3 W5 Y5 Y3 Y5 Y3 W3 Y3 W5

Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y5 Y5 Y3 Y3 Y5 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5

Y3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 Y3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3

G5 G5 G3 G2 G3 Y3 W3 Y3 G5 W5 G2 G2 W5 G5 G5 W3 G3 G2 Y3 W5 W3 G5 W5 G2 Y2 Y3 W5 G3 W3 W2 G2 W3 Y2 G3 G3

G3 G2 G5 G2 W2 G3 W2 W5 Y5 G5 W2 W2 W2 G5 Y2 G5 W5 W3 W2 Y2 G5 W5 W3 W5 Y2 Y5 W2 W2 W3 Y3 G2 W3 G5 G3 W2

W2 W3 Y2 G5 G2 W3 G5 Y2 W5 Y5 W3 G2 G3 W5 W2 W3 Y2 Y5 Y2 Y5 Y2 Y2 G2 Y5 W3 Y5 G3 Y2 G3 Y2 Y5 W5 G3 W5 W5

Y2 Y3 Y2 Y3 Y5 Y5 Y3 Y5 Y5 Y2 Y2 Y5 Y2 Y2 Y5 Y3 Y2 Y5 Y5 Y3 Y3 Y2 Y2 Y2 Y3 Y5 Y2 Y5 Y5 Y3 Y5 Y2 Y3 Y3 Y2

Y5 Y5 W5 Y5 W3 Y3 W5 W3 W5 W3 W5 Y5 Y3 W3 W5 W5 W5 W3 Y5 Y3 Y5 W5 W5 Y3 Y5 Y5 Y3 W5 W3 W3 W3 W5 Y5 W3 W5

G3 G3 W3 W3 G3 G3 Y3 G3 Y3 Y3 G3 W3 Y3 G3 W3 Y3 W3 Y3 Y3 Y3 Y3 G3 G3 Y3 Y3 G3 G3 G3 G3 G3 Y3 W3 W3 W3 G3

R2 R2 R2 R2 G3 G2 Y3 G2 R3 W5 G4 Y3 Y3 G2 Y5 W5 G4 G2 W4 Y2 W3 R5 W5 G4 G4 Y2 G2 Y5 G2 Y4 W3 G5 G2 R3 G4

G2 Y1 Y1 R4 G5 B5 R2 G4 G2 G3 W4 W1 B3 W5 R2 Y5 R4 R4 B5 Y2 B4 B1 R3 G4 Y3 G2 R4 G3 B2 G2 R3 B2 R1 W2 B4

W4 Y5 Y3 Y3 R5 W3 R5 W2 R5 Y2 R2 Y2 G2 G3 Y4 Y4 R4 Y3 G2 W2 R2 R3 Y3 W5 W2 G4 R3 R3 W2 W5 Y4 R3 W2 R4 R2

Y3 Y3 Y3 Y3 Y3 Y3 W3 G3 G3 G3 W3 G3 G3 Y3 Y3 W3 G3 G3 Y3 W3 W3 Y3 Y3 G3 W3 W3 G3 Y3 Y3 W3 G3 W3 G3 W3 G3

W3 Y3 W3 W5 Y5 W3 W3 Y5 W3 W3 W3 W5 W3 Y3 Y5 Y3 Y5 Y3 W3 W3 W5 W5 W3 Y5 W3 W3 Y3 W3 W5 W3 Y3 Y3 Y5 Y5 Y3

Y3 R2 R2 Y2 Y5 Y4 B3 B3 Y4 W3 R1 W3 W5 B5 R1 Y4 B4 B5 B3 G3 B1 R2 R4 G5 Y5

W5 R1 Y3 G5 G3 G5 W2 Y1 R3 R4 B3 G5 G2 Y2 W1 G2 Y1 B4 Y2 G3 G3 Y4 W3 W5 Y2

Y1 W2 G3 W1 G1 G3 G4 W1 B2 W3 R4 B1 G2 Y4 G1 R2 R3 Y4 B2 G4 W2 Y2 R2 Y5 R4

B3 Y1 R3 Y3 R5 B4 B3 G1 R1 B4 B5 W3 R4 W1 B3 Y3 B3 Y4 B2 G5 Y1 G5 R4 B5 Y1

G4 R4 Y1 Y4 R3 B5 W2 G4 B5 B2 G1 B4 R4 G2 Y3 Y4 G5 Y3 R1 G2 Y5 G3 Y3 Y4 W3

R1 R3 G1 B5 Y5 W3 R4 R4 R1 G3 R2 W1 B1 G2 W2 G4 R2 W3 B1 W3 B5 Y5 R2 B4 B5

Y3 R4 G1 W1 R3 R2 W4 W1 R5 Y4 G3 R5 Y2 W1 Y1


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
N = const int = 150
let x[N], y[N], info[N], n be ints
in int function color_to_id taking char ch
    if ch = 'R' then return 1
    if ch = 'G' then return 2
    if ch = 'B' then return 3
    if ch = 'Y' then return 4
    if ch = 'W' then return 5
end of the block
in int function count_one taking x
    cnt = 0 = int
    while x isn't 0
        increment cnt by x&1
        x = x bit right shift 1
    end of the block
    return cnt
end of the block
in bool function check taking sta = int
    for i = 0 to n exclusive
        set info[i] = 0
        info[i] bitwise or (1 bitwise left shift (x[i] - 1)) bitwise and sta
        info[i] bitwise or (1 bitwise left shift (y[i] - 1 + 5)) bitwise and sta
        for j = 0 to i exclusive
            if info[i] = info[j] and (x[i] is not x[j] or y[i] is not y[j])
    end of the block
    return true
end of the block
define the main function
    str = string
    while reading n
        for i = 0 to n exclusive
            read str
            set x[i] = color_to_id of str[0]
            y[i] = str[1] - '0'
        end of the block
        ans = 10 = int
        for i = 0 to 1 bitwise left shit 10
            n_one = count_one(i) = int
            if n_one >= ans then go to next iteration
            if check(i) then set ans to n_one
        end of the block
        print ans
    end of the block
    return to indicate successful execution
end of the block

[CODE]:

const int N = 150;
int x[N], y[N], info[N], n;
int color_to_id(char ch) {
    if (ch == 'R') return 1;
    if (ch == 'G') return 2;
    if (ch == 'B') return 3;
    if (ch == 'Y') return 4;
    if (ch == 'W') return 5;
}
int count_one(int x) {
    int cnt = 0;
    while (x) {
        cnt += (x & 1);
        x >>= 1;
    }
    return cnt;
}
bool check(int sta) {
    for (int i = 0; i < n; i++) {
        info[i] = 0;
        info[i] |= (1 << (x[i] - 1)) & sta;
        info[i] |= (1 << (y[i] - 1 + 5)) & sta;
        for (int j = 0; j < i; j++)
            if (info[i] == info[j] && (x[i] != x[j] || y[i] != y[j])) return false;
    }
    return true;
}
int main() {
    string str;
    while (cin >> n) {
        for (int i = 0; i < n; i++) {
            cin >> str;
            x[i] = color_to_id(str[0]);
            y[i] = str[1] - '0';
        }
        int ans = 10;
        for (int i = 0; i < (1 << 10); i++) {
            int n_one = count_one(i);
            if (n_one >= ans) continue;
            if (check(i)) ans = n_one;
        }
        cout << ans << endl;
    }
    return 0;
}

W4 Y1 W5 R4 W3 Y1 R4 W2 G3 G1 B5 Y5 Y2 Y3 G4 B5 W1 G5 Y5 Y3 G2 Y5 Y5 G5 R2 B3 B1 W5 Y1 W5 B4 W4 R4 B1 R1 W3 R5 R4 G2 W3 W3 R2 W5 Y2 B2 R3 R3 Y1 G5 G2 Y1 R4 Y5 W5 G5 B3 W2 R1 B2 W2 W2 Y5 W3 G1 B1 G2 Y3 W3 G1 W5 W1 G5 G2 Y1 W5 B5 W4 Y5 G2 R3 B4 R5 B1 R1 B4 Y4 Y4 Y3 R5 Y3 B3 W5 R5 Y5 G2 G5 W5 B4 G4 W5

B5 G3 Y2 W3 W1 G1 Y4 G3 G4 B5 W4 B5 Y3 R5 B4 G4 G4 B1 G1 R5 G4 B4 G1 G2 W1 Y4 R5 Y3 W5 W4 Y5 W1 B4 G3 R2 R3 W1 B4 Y4 G2 G2 R1 Y5 W1 Y3 B3 G5 Y3 G3 W2 W5 Y4 B2 Y5 R4 B2 Y3 W4 G2 G3 R2 W1 B4 B2 B1 Y2 Y2 Y3 W3 Y5 W1 R1 R1 R4 R4 R4 Y1 Y3 B2 Y3 Y1 R3 G4 G4 Y5 B5 W2 G1 G5 B3 G1 Y1 R2 G5 R2 Y5 R5 Y4 R4 W2

Y3 Y3 Y5 Y2 Y4 Y1 Y2 Y3 Y1 Y5 Y3 Y1 Y4 Y5 Y5 Y3 Y1 Y5 Y2 Y3 Y1 Y4 Y4 Y1 Y2 Y2 Y4 Y2 Y4 Y5 Y5 Y2 Y3 Y1 Y3 Y5 Y3 Y1 Y5 Y3 Y3 Y2 Y5 Y1 Y5 Y5 Y4 Y2 Y2 Y1 Y2 Y4 Y3 Y2 Y5 Y3 Y4 Y3 Y1 Y4 Y2 Y4 Y4 Y3 Y3 Y1 Y1 Y4 Y2 Y5 Y3 Y4 Y4 Y4 Y3 Y2 Y2 Y2 Y3 Y4 Y4 Y2 Y1 Y2 Y2 Y4 Y3 Y5 Y4 Y2 Y5 Y3 Y1 Y5 Y2 Y5 Y4 Y1 Y2 Y1

G3 B3 G3 Y3 R3 G3 R3 G3 W3 B3 B3 B3 R3 Y3 Y3 W3 R3 B3 G3 W3 G3 W3 Y3 R3 Y3 W3 W3 G3 W3 G3 W3 Y3 G3 R3 Y3 W3 W3 Y3 Y3 Y3 R3 W3 R3 G3 W3 W3 G3 Y3 B3 W3 B3 Y3 G3 Y3 B3 Y3 W3 Y3 R3 Y3 R3 W3 W3 W3 G3 Y3 G3 R3 B3 R3 Y3 R3 Y3 R3 Y3 R3 Y3 R3 W3 Y3 R3 W3 W3 W3 G3 G3 Y3 B3 Y3 R3 G3 G3 B3 B3 Y3 R3 G3 R3 W3 G3

W5 Y5 Y3 W3 Y5 Y5 W5 W5 Y3 W5 Y5 Y3 W5 Y5 W5 W3 Y3 Y5 W3 W5 Y5 W3 Y5 Y3 W3 W3 Y3 Y5 W3 W3 Y3 Y5 W3 Y5 Y5 Y5 W5 Y5 W5 Y5 W5 W5 W3 W5 W3 Y3 W5 W3 W3 W5 Y3 Y5 W5 W5 W3 W5 W5 Y5 W5 W3 W3 W3 Y3 Y5 Y5 Y3 Y5 W5 W5 Y5 W3 W3 W5 Y5 Y5 Y3 W5 W5 W3 Y5 W3 W5 Y3 Y5 W5 Y3 Y3 W3 Y3 Y5 Y3 Y3 W5 Y5 Y3 Y5 Y3 W3 Y3 W5

Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y5 Y5 Y3 Y3 Y5 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5

Y3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 Y3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3

G5 G5 G3 G2 G3 Y3 W3 Y3 G5 W5 G2 G2 W5 G5 G5 W3 G3 G2 Y3 W5 W3 G5 W5 G2 Y2 Y3 W5 G3 W3 W2 G2 W3 Y2 G3 G3

G3 G2 G5 G2 W2 G3 W2 W5 Y5 G5 W2 W2 W2 G5 Y2 G5 W5 W3 W2 Y2 G5 W5 W3 W5 Y2 Y5 W2 W2 W3 Y3 G2 W3 G5 G3 W2

W2 W3 Y2 G5 G2 W3 G5 Y2 W5 Y5 W3 G2 G3 W5 W2 W3 Y2 Y5 Y2 Y5 Y2 Y2 G2 Y5 W3 Y5 G3 Y2 G3 Y2 Y5 W5 G3 W5 W5

Y2 Y3 Y2 Y3 Y5 Y5 Y3 Y5 Y5 Y2 Y2 Y5 Y2 Y2 Y5 Y3 Y2 Y5 Y5 Y3 Y3 Y2 Y2 Y2 Y3 Y5 Y2 Y5 Y5 Y3 Y5 Y2 Y3 Y3 Y2

Y5 Y5 W5 Y5 W3 Y3 W5 W3 W5 W3 W5 Y5 Y3 W3 W5 W5 W5 W3 Y5 Y3 Y5 W5 W5 Y3 Y5 Y5 Y3 W5 W3 W3 W3 W5 Y5 W3 W5

G3 G3 W3 W3 G3 G3 Y3 G3 Y3 Y3 G3 W3 Y3 G3 W3 Y3 W3 Y3 Y3 Y3 Y3 G3 G3 Y3 Y3 G3 G3 G3 G3 G3 Y3 W3 W3 W3 G3

R2 R2 R2 R2 G3 G2 Y3 G2 R3 W5 G4 Y3 Y3 G2 Y5 W5 G4 G2 W4 Y2 W3 R5 W5 G4 G4 Y2 G2 Y5 G2 Y4 W3 G5 G2 R3 G4

G2 Y1 Y1 R4 G5 B5 R2 G4 G2 G3 W4 W1 B3 W5 R2 Y5 R4 R4 B5 Y2 B4 B1 R3 G4 Y3 G2 R4 G3 B2 G2 R3 B2 R1 W2 B4

W4 Y5 Y3 Y3 R5 W3 R5 W2 R5 Y2 R2 Y2 G2 G3 Y4 Y4 R4 Y3 G2 W2 R2 R3 Y3 W5 W2 G4 R3 R3 W2 W5 Y4 R3 W2 R4 R2

Y3 Y3 Y3 Y3 Y3 Y3 W3 G3 G3 G3 W3 G3 G3 Y3 Y3 W3 G3 G3 Y3 W3 W3 Y3 Y3 G3 W3 W3 G3 Y3 Y3 W3 G3 W3 G3 W3 G3

W3 Y3 W3 W5 Y5 W3 W3 Y5 W3 W3 W3 W5 W3 Y3 Y5 Y3 Y5 Y3 W3 W3 W5 W5 W3 Y5 W3 W3 Y3 W3 W5 W3 Y3 Y3 Y5 Y5 Y3

Y3 R2 R2 Y2 Y5 Y4 B3 B3 Y4 W3 R1 W3 W5 B5 R1 Y4 B4 B5 B3 G3 B1 R2 R4 G5 Y5

W5 R1 Y3 G5 G3 G5 W2 Y1 R3 R4 B3 G5 G2 Y2 W1 G2 Y1 B4 Y2 G3 G3 Y4 W3 W5 Y2

Y1 W2 G3 W1 G1 G3 G4 W1 B2 W3 R4 B1 G2 Y4 G1 R2 R3 Y4 B2 G4 W2 Y2 R2 Y5 R4

B3 Y1 R3 Y3 R5 B4 B3 G1 R1 B4 B5 W3 R4 W1 B3 Y3 B3 Y4 B2 G5 Y1 G5 R4 B5 Y1

G4 R4 Y1 Y4 R3 B5 W2 G4 B5 B2 G1 B4 R4 G2 Y3 Y4 G5 Y3 R1 G2 Y5 G3 Y3 Y4 W3

R1 R3 G1 B5 Y5 W3 R4 R4 R1 G3 R2 W1 B1 G2 W2 G4 R2 W3 B1 W3 B5 Y5 R2 B4 B5

Y3 R4 G1 W1 R3 R2 W4 W1 R5 Y4 G3 R5 Y2 W1 Y1


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
create integer n, array a with size 105
create map mp of char to int
define the main function
    read n
    set mp['R'] to 5
    set mp['G'] to 6
    set mp['B'] to 7
    set mp['Y'] to 8
    set mp['W'] to 9
    for i = 0 to n exclusive
        create stirng s
        read s
        create ints c, v
        set c to mp[s[0]]
        set v to s[1] - '0' - 1
        set a[i] to (1 bitwise shift left c) bitwise or (1 bitwise shift left v)
    end of the block
    sort a [0:n)
    set n to unique(a, a + n) - a
    create integer ans = 11
    for int mask = 0; msk less than (1 bitwise shift left 10); increment msk
        create bool f = true
        for i = 0 to n exclusive
            for j = i + 1 to n exclusive
                create int t = a[i] bitwise XOR a[j]
                if (msk bitwise and t) equals 0
                    set f to false
                    break
                end of the block
            end of the block
            if not f, break
        end of the block
        if f, set ans to min(ans, __builtin_popcount(msk))
    end of the block
    print ans
    return to indicate successful execution
end of the block

[CODE]:

int n, a[105];
map<char, int> mp;
int main() {
    cin >> n;
    mp['R'] = 5;
    mp['G'] = 6;
    mp['B'] = 7;
    mp['Y'] = 8;
    mp['W'] = 9;
    for (int i = 0; i < n; i++) {
        string s;
        cin >> s;
        int c, v;
        c = mp[s[0]];
        v = s[1] - '0' - 1;
        a[i] = (1 << c) | (1 << v);
    }
    sort(a, a + n);
    n = unique(a, a + n) - a;
    int ans = 11;
    for (int msk = 0; msk < (1 << 10); msk++) {
        bool f = true;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int t = a[i] ^ a[j];
                if ((msk & t) == 0) {
                    f = false;
                    break;
                }
            }
            if (!f) break;
        }
        if (f) { ans = min(ans, __builtin_popcount(msk)); }
    }
    cout << ans << endl;
    return 0;
}

W4 Y1 W5 R4 W3 Y1 R4 W2 G3 G1 B5 Y5 Y2 Y3 G4 B5 W1 G5 Y5 Y3 G2 Y5 Y5 G5 R2 B3 B1 W5 Y1 W5 B4 W4 R4 B1 R1 W3 R5 R4 G2 W3 W3 R2 W5 Y2 B2 R3 R3 Y1 G5 G2 Y1 R4 Y5 W5 G5 B3 W2 R1 B2 W2 W2 Y5 W3 G1 B1 G2 Y3 W3 G1 W5 W1 G5 G2 Y1 W5 B5 W4 Y5 G2 R3 B4 R5 B1 R1 B4 Y4 Y4 Y3 R5 Y3 B3 W5 R5 Y5 G2 G5 W5 B4 G4 W5

B5 G3 Y2 W3 W1 G1 Y4 G3 G4 B5 W4 B5 Y3 R5 B4 G4 G4 B1 G1 R5 G4 B4 G1 G2 W1 Y4 R5 Y3 W5 W4 Y5 W1 B4 G3 R2 R3 W1 B4 Y4 G2 G2 R1 Y5 W1 Y3 B3 G5 Y3 G3 W2 W5 Y4 B2 Y5 R4 B2 Y3 W4 G2 G3 R2 W1 B4 B2 B1 Y2 Y2 Y3 W3 Y5 W1 R1 R1 R4 R4 R4 Y1 Y3 B2 Y3 Y1 R3 G4 G4 Y5 B5 W2 G1 G5 B3 G1 Y1 R2 G5 R2 Y5 R5 Y4 R4 W2

Y3 Y3 Y5 Y2 Y4 Y1 Y2 Y3 Y1 Y5 Y3 Y1 Y4 Y5 Y5 Y3 Y1 Y5 Y2 Y3 Y1 Y4 Y4 Y1 Y2 Y2 Y4 Y2 Y4 Y5 Y5 Y2 Y3 Y1 Y3 Y5 Y3 Y1 Y5 Y3 Y3 Y2 Y5 Y1 Y5 Y5 Y4 Y2 Y2 Y1 Y2 Y4 Y3 Y2 Y5 Y3 Y4 Y3 Y1 Y4 Y2 Y4 Y4 Y3 Y3 Y1 Y1 Y4 Y2 Y5 Y3 Y4 Y4 Y4 Y3 Y2 Y2 Y2 Y3 Y4 Y4 Y2 Y1 Y2 Y2 Y4 Y3 Y5 Y4 Y2 Y5 Y3 Y1 Y5 Y2 Y5 Y4 Y1 Y2 Y1

G3 B3 G3 Y3 R3 G3 R3 G3 W3 B3 B3 B3 R3 Y3 Y3 W3 R3 B3 G3 W3 G3 W3 Y3 R3 Y3 W3 W3 G3 W3 G3 W3 Y3 G3 R3 Y3 W3 W3 Y3 Y3 Y3 R3 W3 R3 G3 W3 W3 G3 Y3 B3 W3 B3 Y3 G3 Y3 B3 Y3 W3 Y3 R3 Y3 R3 W3 W3 W3 G3 Y3 G3 R3 B3 R3 Y3 R3 Y3 R3 Y3 R3 Y3 R3 W3 Y3 R3 W3 W3 W3 G3 G3 Y3 B3 Y3 R3 G3 G3 B3 B3 Y3 R3 G3 R3 W3 G3

W5 Y5 Y3 W3 Y5 Y5 W5 W5 Y3 W5 Y5 Y3 W5 Y5 W5 W3 Y3 Y5 W3 W5 Y5 W3 Y5 Y3 W3 W3 Y3 Y5 W3 W3 Y3 Y5 W3 Y5 Y5 Y5 W5 Y5 W5 Y5 W5 W5 W3 W5 W3 Y3 W5 W3 W3 W5 Y3 Y5 W5 W5 W3 W5 W5 Y5 W5 W3 W3 W3 Y3 Y5 Y5 Y3 Y5 W5 W5 Y5 W3 W3 W5 Y5 Y5 Y3 W5 W5 W3 Y5 W3 W5 Y3 Y5 W5 Y3 Y3 W3 Y3 Y5 Y3 Y3 W5 Y5 Y3 Y5 Y3 W3 Y3 W5

Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y5 Y5 Y3 Y3 Y5 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5

Y3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 Y3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3

G5 G5 G3 G2 G3 Y3 W3 Y3 G5 W5 G2 G2 W5 G5 G5 W3 G3 G2 Y3 W5 W3 G5 W5 G2 Y2 Y3 W5 G3 W3 W2 G2 W3 Y2 G3 G3

G3 G2 G5 G2 W2 G3 W2 W5 Y5 G5 W2 W2 W2 G5 Y2 G5 W5 W3 W2 Y2 G5 W5 W3 W5 Y2 Y5 W2 W2 W3 Y3 G2 W3 G5 G3 W2

W2 W3 Y2 G5 G2 W3 G5 Y2 W5 Y5 W3 G2 G3 W5 W2 W3 Y2 Y5 Y2 Y5 Y2 Y2 G2 Y5 W3 Y5 G3 Y2 G3 Y2 Y5 W5 G3 W5 W5

Y2 Y3 Y2 Y3 Y5 Y5 Y3 Y5 Y5 Y2 Y2 Y5 Y2 Y2 Y5 Y3 Y2 Y5 Y5 Y3 Y3 Y2 Y2 Y2 Y3 Y5 Y2 Y5 Y5 Y3 Y5 Y2 Y3 Y3 Y2

Y5 Y5 W5 Y5 W3 Y3 W5 W3 W5 W3 W5 Y5 Y3 W3 W5 W5 W5 W3 Y5 Y3 Y5 W5 W5 Y3 Y5 Y5 Y3 W5 W3 W3 W3 W5 Y5 W3 W5

G3 G3 W3 W3 G3 G3 Y3 G3 Y3 Y3 G3 W3 Y3 G3 W3 Y3 W3 Y3 Y3 Y3 Y3 G3 G3 Y3 Y3 G3 G3 G3 G3 G3 Y3 W3 W3 W3 G3

R2 R2 R2 R2 G3 G2 Y3 G2 R3 W5 G4 Y3 Y3 G2 Y5 W5 G4 G2 W4 Y2 W3 R5 W5 G4 G4 Y2 G2 Y5 G2 Y4 W3 G5 G2 R3 G4

G2 Y1 Y1 R4 G5 B5 R2 G4 G2 G3 W4 W1 B3 W5 R2 Y5 R4 R4 B5 Y2 B4 B1 R3 G4 Y3 G2 R4 G3 B2 G2 R3 B2 R1 W2 B4

W4 Y5 Y3 Y3 R5 W3 R5 W2 R5 Y2 R2 Y2 G2 G3 Y4 Y4 R4 Y3 G2 W2 R2 R3 Y3 W5 W2 G4 R3 R3 W2 W5 Y4 R3 W2 R4 R2

Y3 Y3 Y3 Y3 Y3 Y3 W3 G3 G3 G3 W3 G3 G3 Y3 Y3 W3 G3 G3 Y3 W3 W3 Y3 Y3 G3 W3 W3 G3 Y3 Y3 W3 G3 W3 G3 W3 G3

W3 Y3 W3 W5 Y5 W3 W3 Y5 W3 W3 W3 W5 W3 Y3 Y5 Y3 Y5 Y3 W3 W3 W5 W5 W3 Y5 W3 W3 Y3 W3 W5 W3 Y3 Y3 Y5 Y5 Y3

Y3 R2 R2 Y2 Y5 Y4 B3 B3 Y4 W3 R1 W3 W5 B5 R1 Y4 B4 B5 B3 G3 B1 R2 R4 G5 Y5

W5 R1 Y3 G5 G3 G5 W2 Y1 R3 R4 B3 G5 G2 Y2 W1 G2 Y1 B4 Y2 G3 G3 Y4 W3 W5 Y2

Y1 W2 G3 W1 G1 G3 G4 W1 B2 W3 R4 B1 G2 Y4 G1 R2 R3 Y4 B2 G4 W2 Y2 R2 Y5 R4

B3 Y1 R3 Y3 R5 B4 B3 G1 R1 B4 B5 W3 R4 W1 B3 Y3 B3 Y4 B2 G5 Y1 G5 R4 B5 Y1

G4 R4 Y1 Y4 R3 B5 W2 G4 B5 B2 G1 B4 R4 G2 Y3 Y4 G5 Y3 R1 G2 Y5 G3 Y3 Y4 W3

R1 R3 G1 B5 Y5 W3 R4 R4 R1 G3 R2 W1 B1 G2 W2 G4 R2 W3 B1 W3 B5 Y5 R2 B4 B5

Y3 R4 G1 W1 R3 R2 W4 W1 R5 Y4 G3 R5 Y2 W1 Y1


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
create ints ans and n and int array b of size 20
make bool array a of size 10 with array of size 10
declare check returning bool
    make ints i, j, r, l, and tot
    for i = 1 to 5
        set l and r to 0
        for j = 1 to 5
            if a[i][j] is truthy
                increment l
                if b[j] is truthy, add 1 to r
            end of the block
        end of the block
        if l - 1 is greater than r, return false
    end of the block
    for i = 1 to 5
        set l and r to 0
        for j = 1 to 5
            if a[j][i] is truthy
                increment l
                if b[5 + j] is truthy, increment r
            end of the block
        end of the block
        if l - 1 is greater than r, return false
    end of the block
    set tot to 0
    for i = 1 to 5
        for j = 1 to 5
            if a[i][j] is truthy, !b[i + 5] is truthy, and b[j] is falsy, increment tot
        end of the block
    end of the block
    if tot is greater than 1, return false
    return true
end of the block
declare dfs taking in integer x
    make ints i and sum
    if x is equal to 11
        if check() returns true
            set sum to 0
            for i = 1 to 11
                if b[i] is equal to 1, add 1 to sum
            end of the block
            set ans to min of sum and ans
        end of the block
        return
    end of the block
    set b[x] to 1
    call dfs(x + 1)
    set b[x] to 0
    call dfs(x + 1)
end of the block
define the main function
    create ints i and y
    make char ch
    let integer k
    read n
    set all contents of a to false
    for i = 1 to n
        read ch and k
        if ch is equal to 'R'
            set y to 1
        else if ch is equal to 'G'
            set y to 2
        else if ch is equal to 'B'
            set y to 3
        else if ch is equal to 'Y'
            set y to 4
        else if ch is equal to 'W'
            set y to 5
        set a[y][k] to true
    end of the block
    set all contents of b to 0
    set ans to 9999999
    end statement
    call dfs(1)
    show ans
end of the block

[CODE]:

int b[20], ans, n;
bool a[10][10];
bool check() {
    int i, j, r, l, tot;
    for (i = 1; i <= 5; i++) {
        l = r = 0;
        for (j = 1; j <= 5; j++) {
            if (a[i][j]) {
                l++;
                if (b[j]) { r++; }
            }
        }
        if (l - 1 > r) return false;
    }
    for (i = 1; i <= 5; i++) {
        l = r = 0;
        for (j = 1; j <= 5; j++) {
            if (a[j][i]) {
                l++;
                if (b[5 + j]) r++;
            }
        }
        if (l - 1 > r) return false;
    }
    tot = 0;
    for (i = 1; i <= 5; i++) {
        for (j = 1; j <= 5; j++) {
            if (a[i][j] && !b[i + 5] && !b[j]) tot++;
        }
    }
    if (tot > 1) return false;
    return true;
}
void dfs(int x) {
    int i, sum;
    if (x == 11) {
        if (check()) {
            sum = 0;
            for (i = 1; i <= 11; i++) {
                if (b[i] == 1) sum++;
            }
            ans = min(sum, ans);
        }
        return;
    }
    b[x] = 1;
    dfs(x + 1);
    b[x] = 0;
    dfs(x + 1);
}
int main() {
    int i, y;
    char ch;
    int k;
    cin >> n;
    memset(a, false, sizeof(a));
    for (i = 1; i <= n; i++) {
        cin >> ch >> k;
        if (ch == 'R')
            y = 1;
        else if (ch == 'G')
            y = 2;
        else if (ch == 'B')
            y = 3;
        else if (ch == 'Y')
            y = 4;
        else if (ch == 'W')
            y = 5;
        a[y][k] = true;
    }
    memset(b, 0, sizeof(b));
    ans = 9999999;
    ;
    dfs(1);
    cout << ans << endl;
}

W4 Y1 W5 R4 W3 Y1 R4 W2 G3 G1 B5 Y5 Y2 Y3 G4 B5 W1 G5 Y5 Y3 G2 Y5 Y5 G5 R2 B3 B1 W5 Y1 W5 B4 W4 R4 B1 R1 W3 R5 R4 G2 W3 W3 R2 W5 Y2 B2 R3 R3 Y1 G5 G2 Y1 R4 Y5 W5 G5 B3 W2 R1 B2 W2 W2 Y5 W3 G1 B1 G2 Y3 W3 G1 W5 W1 G5 G2 Y1 W5 B5 W4 Y5 G2 R3 B4 R5 B1 R1 B4 Y4 Y4 Y3 R5 Y3 B3 W5 R5 Y5 G2 G5 W5 B4 G4 W5

B5 G3 Y2 W3 W1 G1 Y4 G3 G4 B5 W4 B5 Y3 R5 B4 G4 G4 B1 G1 R5 G4 B4 G1 G2 W1 Y4 R5 Y3 W5 W4 Y5 W1 B4 G3 R2 R3 W1 B4 Y4 G2 G2 R1 Y5 W1 Y3 B3 G5 Y3 G3 W2 W5 Y4 B2 Y5 R4 B2 Y3 W4 G2 G3 R2 W1 B4 B2 B1 Y2 Y2 Y3 W3 Y5 W1 R1 R1 R4 R4 R4 Y1 Y3 B2 Y3 Y1 R3 G4 G4 Y5 B5 W2 G1 G5 B3 G1 Y1 R2 G5 R2 Y5 R5 Y4 R4 W2

Y3 Y3 Y5 Y2 Y4 Y1 Y2 Y3 Y1 Y5 Y3 Y1 Y4 Y5 Y5 Y3 Y1 Y5 Y2 Y3 Y1 Y4 Y4 Y1 Y2 Y2 Y4 Y2 Y4 Y5 Y5 Y2 Y3 Y1 Y3 Y5 Y3 Y1 Y5 Y3 Y3 Y2 Y5 Y1 Y5 Y5 Y4 Y2 Y2 Y1 Y2 Y4 Y3 Y2 Y5 Y3 Y4 Y3 Y1 Y4 Y2 Y4 Y4 Y3 Y3 Y1 Y1 Y4 Y2 Y5 Y3 Y4 Y4 Y4 Y3 Y2 Y2 Y2 Y3 Y4 Y4 Y2 Y1 Y2 Y2 Y4 Y3 Y5 Y4 Y2 Y5 Y3 Y1 Y5 Y2 Y5 Y4 Y1 Y2 Y1

G3 B3 G3 Y3 R3 G3 R3 G3 W3 B3 B3 B3 R3 Y3 Y3 W3 R3 B3 G3 W3 G3 W3 Y3 R3 Y3 W3 W3 G3 W3 G3 W3 Y3 G3 R3 Y3 W3 W3 Y3 Y3 Y3 R3 W3 R3 G3 W3 W3 G3 Y3 B3 W3 B3 Y3 G3 Y3 B3 Y3 W3 Y3 R3 Y3 R3 W3 W3 W3 G3 Y3 G3 R3 B3 R3 Y3 R3 Y3 R3 Y3 R3 Y3 R3 W3 Y3 R3 W3 W3 W3 G3 G3 Y3 B3 Y3 R3 G3 G3 B3 B3 Y3 R3 G3 R3 W3 G3

W5 Y5 Y3 W3 Y5 Y5 W5 W5 Y3 W5 Y5 Y3 W5 Y5 W5 W3 Y3 Y5 W3 W5 Y5 W3 Y5 Y3 W3 W3 Y3 Y5 W3 W3 Y3 Y5 W3 Y5 Y5 Y5 W5 Y5 W5 Y5 W5 W5 W3 W5 W3 Y3 W5 W3 W3 W5 Y3 Y5 W5 W5 W3 W5 W5 Y5 W5 W3 W3 W3 Y3 Y5 Y5 Y3 Y5 W5 W5 Y5 W3 W3 W5 Y5 Y5 Y3 W5 W5 W3 Y5 W3 W5 Y3 Y5 W5 Y3 Y3 W3 Y3 Y5 Y3 Y3 W5 Y5 Y3 Y5 Y3 W3 Y3 W5

Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y5 Y5 Y3 Y3 Y5 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5

Y3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 Y3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3

G5 G5 G3 G2 G3 Y3 W3 Y3 G5 W5 G2 G2 W5 G5 G5 W3 G3 G2 Y3 W5 W3 G5 W5 G2 Y2 Y3 W5 G3 W3 W2 G2 W3 Y2 G3 G3

G3 G2 G5 G2 W2 G3 W2 W5 Y5 G5 W2 W2 W2 G5 Y2 G5 W5 W3 W2 Y2 G5 W5 W3 W5 Y2 Y5 W2 W2 W3 Y3 G2 W3 G5 G3 W2

W2 W3 Y2 G5 G2 W3 G5 Y2 W5 Y5 W3 G2 G3 W5 W2 W3 Y2 Y5 Y2 Y5 Y2 Y2 G2 Y5 W3 Y5 G3 Y2 G3 Y2 Y5 W5 G3 W5 W5

Y2 Y3 Y2 Y3 Y5 Y5 Y3 Y5 Y5 Y2 Y2 Y5 Y2 Y2 Y5 Y3 Y2 Y5 Y5 Y3 Y3 Y2 Y2 Y2 Y3 Y5 Y2 Y5 Y5 Y3 Y5 Y2 Y3 Y3 Y2

Y5 Y5 W5 Y5 W3 Y3 W5 W3 W5 W3 W5 Y5 Y3 W3 W5 W5 W5 W3 Y5 Y3 Y5 W5 W5 Y3 Y5 Y5 Y3 W5 W3 W3 W3 W5 Y5 W3 W5

G3 G3 W3 W3 G3 G3 Y3 G3 Y3 Y3 G3 W3 Y3 G3 W3 Y3 W3 Y3 Y3 Y3 Y3 G3 G3 Y3 Y3 G3 G3 G3 G3 G3 Y3 W3 W3 W3 G3

R2 R2 R2 R2 G3 G2 Y3 G2 R3 W5 G4 Y3 Y3 G2 Y5 W5 G4 G2 W4 Y2 W3 R5 W5 G4 G4 Y2 G2 Y5 G2 Y4 W3 G5 G2 R3 G4

G2 Y1 Y1 R4 G5 B5 R2 G4 G2 G3 W4 W1 B3 W5 R2 Y5 R4 R4 B5 Y2 B4 B1 R3 G4 Y3 G2 R4 G3 B2 G2 R3 B2 R1 W2 B4

W4 Y5 Y3 Y3 R5 W3 R5 W2 R5 Y2 R2 Y2 G2 G3 Y4 Y4 R4 Y3 G2 W2 R2 R3 Y3 W5 W2 G4 R3 R3 W2 W5 Y4 R3 W2 R4 R2

Y3 Y3 Y3 Y3 Y3 Y3 W3 G3 G3 G3 W3 G3 G3 Y3 Y3 W3 G3 G3 Y3 W3 W3 Y3 Y3 G3 W3 W3 G3 Y3 Y3 W3 G3 W3 G3 W3 G3

W3 Y3 W3 W5 Y5 W3 W3 Y5 W3 W3 W3 W5 W3 Y3 Y5 Y3 Y5 Y3 W3 W3 W5 W5 W3 Y5 W3 W3 Y3 W3 W5 W3 Y3 Y3 Y5 Y5 Y3

Y3 R2 R2 Y2 Y5 Y4 B3 B3 Y4 W3 R1 W3 W5 B5 R1 Y4 B4 B5 B3 G3 B1 R2 R4 G5 Y5

W5 R1 Y3 G5 G3 G5 W2 Y1 R3 R4 B3 G5 G2 Y2 W1 G2 Y1 B4 Y2 G3 G3 Y4 W3 W5 Y2

Y1 W2 G3 W1 G1 G3 G4 W1 B2 W3 R4 B1 G2 Y4 G1 R2 R3 Y4 B2 G4 W2 Y2 R2 Y5 R4

B3 Y1 R3 Y3 R5 B4 B3 G1 R1 B4 B5 W3 R4 W1 B3 Y3 B3 Y4 B2 G5 Y1 G5 R4 B5 Y1

G4 R4 Y1 Y4 R3 B5 W2 G4 B5 B2 G1 B4 R4 G2 Y3 Y4 G5 Y3 R1 G2 Y5 G3 Y3 Y4 W3

R1 R3 G1 B5 Y5 W3 R4 R4 R1 G3 R2 W1 B1 G2 W2 G4 R2 W3 B1 W3 B5 Y5 R2 B4 B5

Y3 R4 G1 W1 R3 R2 W4 W1 R5 Y4 G3 R5 Y2 W1 Y1


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
make int arrays a of size 1000 and b of size 1000
create char C of size 1000
declare B taking in integer x and returning integer
    create int ans = 0
    for i = 0 to 10 exclusive
        if (1 << i) & x is truthy, increment ans
    return ans
end of the block
define the main function
    create integer n
    read n
    for i = 0 to n exclusive
        read C[i] and a[i]
        decrease a[i] by 1
        if C[i] is equal to 'R', set b[i] to 0
        if C[i] is equal to 'Y', set b[i] to 1
        if C[i] is equal to 'W', set b[i] to 2
        if C[i] is equal to 'G', set b[i] to 3
        if C[i] is equal to 'B', set b[i] to 4
    end of the block
    make integer ans = n + 1
    for i = 0 to 32 exclusive
        for j = 0 to 32 exclusive
            make int arrays f of size 5 and g of size 5
            for k = 0 to 5 exclusive
                if (1 << k) & 1 is truthy
                    set f[k] to 1
                else do
                    set f[k] to 0
            for k = 0 to 5 exclusive
                if (1 << k) & j is truthy
                    set g[k] to 1
                otherwise
                    set g[k] to 0
            create integer f1 = 1
            for i = 0 to n exclusive
                for j = i + 1 to n exclusive
                    if a[i] is equal to a[j] and b[i] is equal to b[i], continue loop
                    if a[i] is equal to a[j] and g[b[i]] | g[b[j]] is truthy, continue to next loop iteration
                    if b[i] is equal to b[j] and f[a[i]] | f[a[j]] is truthy, continue loop
                    if a[i] is not equal to a[j] and b[i] is not equal to b[j] and f[a[i]] | f[a[j]] | g[b[i]] | g[b[j]] is truthy, continue loop
                    set f1 to 0
                end of the block
            if f1 is truthy, set ans to min of ans and B(i) + B(j)
        end of the block
    end of the block
    show ans
end of the block

[CODE]:

W4 Y1 W5 R4 W3 Y1 R4 W2 G3 G1 B5 Y5 Y2 Y3 G4 B5 W1 G5 Y5 Y3 G2 Y5 Y5 G5 R2 B3 B1 W5 Y1 W5 B4 W4 R4 B1 R1 W3 R5 R4 G2 W3 W3 R2 W5 Y2 B2 R3 R3 Y1 G5 G2 Y1 R4 Y5 W5 G5 B3 W2 R1 B2 W2 W2 Y5 W3 G1 B1 G2 Y3 W3 G1 W5 W1 G5 G2 Y1 W5 B5 W4 Y5 G2 R3 B4 R5 B1 R1 B4 Y4 Y4 Y3 R5 Y3 B3 W5 R5 Y5 G2 G5 W5 B4 G4 W5

B5 G3 Y2 W3 W1 G1 Y4 G3 G4 B5 W4 B5 Y3 R5 B4 G4 G4 B1 G1 R5 G4 B4 G1 G2 W1 Y4 R5 Y3 W5 W4 Y5 W1 B4 G3 R2 R3 W1 B4 Y4 G2 G2 R1 Y5 W1 Y3 B3 G5 Y3 G3 W2 W5 Y4 B2 Y5 R4 B2 Y3 W4 G2 G3 R2 W1 B4 B2 B1 Y2 Y2 Y3 W3 Y5 W1 R1 R1 R4 R4 R4 Y1 Y3 B2 Y3 Y1 R3 G4 G4 Y5 B5 W2 G1 G5 B3 G1 Y1 R2 G5 R2 Y5 R5 Y4 R4 W2

Y3 Y3 Y5 Y2 Y4 Y1 Y2 Y3 Y1 Y5 Y3 Y1 Y4 Y5 Y5 Y3 Y1 Y5 Y2 Y3 Y1 Y4 Y4 Y1 Y2 Y2 Y4 Y2 Y4 Y5 Y5 Y2 Y3 Y1 Y3 Y5 Y3 Y1 Y5 Y3 Y3 Y2 Y5 Y1 Y5 Y5 Y4 Y2 Y2 Y1 Y2 Y4 Y3 Y2 Y5 Y3 Y4 Y3 Y1 Y4 Y2 Y4 Y4 Y3 Y3 Y1 Y1 Y4 Y2 Y5 Y3 Y4 Y4 Y4 Y3 Y2 Y2 Y2 Y3 Y4 Y4 Y2 Y1 Y2 Y2 Y4 Y3 Y5 Y4 Y2 Y5 Y3 Y1 Y5 Y2 Y5 Y4 Y1 Y2 Y1

G3 B3 G3 Y3 R3 G3 R3 G3 W3 B3 B3 B3 R3 Y3 Y3 W3 R3 B3 G3 W3 G3 W3 Y3 R3 Y3 W3 W3 G3 W3 G3 W3 Y3 G3 R3 Y3 W3 W3 Y3 Y3 Y3 R3 W3 R3 G3 W3 W3 G3 Y3 B3 W3 B3 Y3 G3 Y3 B3 Y3 W3 Y3 R3 Y3 R3 W3 W3 W3 G3 Y3 G3 R3 B3 R3 Y3 R3 Y3 R3 Y3 R3 Y3 R3 W3 Y3 R3 W3 W3 W3 G3 G3 Y3 B3 Y3 R3 G3 G3 B3 B3 Y3 R3 G3 R3 W3 G3

W5 Y5 Y3 W3 Y5 Y5 W5 W5 Y3 W5 Y5 Y3 W5 Y5 W5 W3 Y3 Y5 W3 W5 Y5 W3 Y5 Y3 W3 W3 Y3 Y5 W3 W3 Y3 Y5 W3 Y5 Y5 Y5 W5 Y5 W5 Y5 W5 W5 W3 W5 W3 Y3 W5 W3 W3 W5 Y3 Y5 W5 W5 W3 W5 W5 Y5 W5 W3 W3 W3 Y3 Y5 Y5 Y3 Y5 W5 W5 Y5 W3 W3 W5 Y5 Y5 Y3 W5 W5 W3 Y5 W3 W5 Y3 Y5 W5 Y3 Y3 W3 Y3 Y5 Y3 Y3 W5 Y5 Y3 Y5 Y3 W3 Y3 W5

Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y5 Y5 Y3 Y3 Y5 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5 Y3 Y3 Y3 Y5 Y3 Y3 Y5 Y3 Y3 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y3 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y5 Y3 Y5 Y5 Y5 Y5 Y5 Y5 Y3 Y3 Y3 Y5 Y5

Y3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 Y3 W3 Y3 Y3 Y3 W3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 W3 Y3 W3 W3 W3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 W3 Y3 Y3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 W3 W3 W3 Y3 W3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 Y3 W3 Y3 Y3 W3 W3 Y3

G5 G5 G3 G2 G3 Y3 W3 Y3 G5 W5 G2 G2 W5 G5 G5 W3 G3 G2 Y3 W5 W3 G5 W5 G2 Y2 Y3 W5 G3 W3 W2 G2 W3 Y2 G3 G3

G3 G2 G5 G2 W2 G3 W2 W5 Y5 G5 W2 W2 W2 G5 Y2 G5 W5 W3 W2 Y2 G5 W5 W3 W5 Y2 Y5 W2 W2 W3 Y3 G2 W3 G5 G3 W2

W2 W3 Y2 G5 G2 W3 G5 Y2 W5 Y5 W3 G2 G3 W5 W2 W3 Y2 Y5 Y2 Y5 Y2 Y2 G2 Y5 W3 Y5 G3 Y2 G3 Y2 Y5 W5 G3 W5 W5

Y2 Y3 Y2 Y3 Y5 Y5 Y3 Y5 Y5 Y2 Y2 Y5 Y2 Y2 Y5 Y3 Y2 Y5 Y5 Y3 Y3 Y2 Y2 Y2 Y3 Y5 Y2 Y5 Y5 Y3 Y5 Y2 Y3 Y3 Y2

Y5 Y5 W5 Y5 W3 Y3 W5 W3 W5 W3 W5 Y5 Y3 W3 W5 W5 W5 W3 Y5 Y3 Y5 W5 W5 Y3 Y5 Y5 Y3 W5 W3 W3 W3 W5 Y5 W3 W5

G3 G3 W3 W3 G3 G3 Y3 G3 Y3 Y3 G3 W3 Y3 G3 W3 Y3 W3 Y3 Y3 Y3 Y3 G3 G3 Y3 Y3 G3 G3 G3 G3 G3 Y3 W3 W3 W3 G3

R2 R2 R2 R2 G3 G2 Y3 G2 R3 W5 G4 Y3 Y3 G2 Y5 W5 G4 G2 W4 Y2 W3 R5 W5 G4 G4 Y2 G2 Y5 G2 Y4 W3 G5 G2 R3 G4

G2 Y1 Y1 R4 G5 B5 R2 G4 G2 G3 W4 W1 B3 W5 R2 Y5 R4 R4 B5 Y2 B4 B1 R3 G4 Y3 G2 R4 G3 B2 G2 R3 B2 R1 W2 B4

W4 Y5 Y3 Y3 R5 W3 R5 W2 R5 Y2 R2 Y2 G2 G3 Y4 Y4 R4 Y3 G2 W2 R2 R3 Y3 W5 W2 G4 R3 R3 W2 W5 Y4 R3 W2 R4 R2

Y3 Y3 Y3 Y3 Y3 Y3 W3 G3 G3 G3 W3 G3 G3 Y3 Y3 W3 G3 G3 Y3 W3 W3 Y3 Y3 G3 W3 W3 G3 Y3 Y3 W3 G3 W3 G3 W3 G3

W3 Y3 W3 W5 Y5 W3 W3 Y5 W3 W3 W3 W5 W3 Y3 Y5 Y3 Y5 Y3 W3 W3 W5 W5 W3 Y5 W3 W3 Y3 W3 W5 W3 Y3 Y3 Y5 Y5 Y3

Y3 R2 R2 Y2 Y5 Y4 B3 B3 Y4 W3 R1 W3 W5 B5 R1 Y4 B4 B5 B3 G3 B1 R2 R4 G5 Y5

W5 R1 Y3 G5 G3 G5 W2 Y1 R3 R4 B3 G5 G2 Y2 W1 G2 Y1 B4 Y2 G3 G3 Y4 W3 W5 Y2

Y1 W2 G3 W1 G1 G3 G4 W1 B2 W3 R4 B1 G2 Y4 G1 R2 R3 Y4 B2 G4 W2 Y2 R2 Y5 R4

B3 Y1 R3 Y3 R5 B4 B3 G1 R1 B4 B5 W3 R4 W1 B3 Y3 B3 Y4 B2 G5 Y1 G5 R4 B5 Y1

G4 R4 Y1 Y4 R3 B5 W2 G4 B5 B2 G1 B4 R4 G2 Y3 Y4 G5 Y3 R1 G2 Y5 G3 Y3 Y4 W3

R1 R3 G1 B5 Y5 W3 R4 R4 R1 G3 R2 W1 B1 G2 W2 G4 R2 W3 B1 W3 B5 Y5 R2 B4 B5

Y3 R4 G1 W1 R3 R2 W4 W1 R5 Y4 G3 R5 Y2 W1 Y1


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
Mod = const int with Mod = 1e9 + 7
n, p = integers
choose, ans = long long with choose = 2d array of 30025 rows and 600 columns, ans = 1
Pedy = map from int to int
define the main function
    read n
    index 0, 0 of choose = 1
    for i = 1 to 30024
        index i and 0 of choose = 1
        for j = 1 to n index i and j of choose = (choose[i - 1][j - 1] + choose[i - 1][j]) modulo Mod
    end of the block
    for i = 0 to n exclusive
        read p
        for j = 2 to j * j <= p
            if p modulo j is 0
                while not(p modulo j)
                    p = p / j
                    increment Pedy[j]
                end of the block
            end of the block
        if p > 1, increment Pedy[p]
    end of the block
    for it = Pedy.begin() to it is not Pedy.end()
        p = second in it
        ans = (ans * choose[p + n - 1][n - 1]) modulo Mod
    end of the block
    print ans
    return to indicate successful execution
end of the block

[CODE]:

const int Mod = 1e9 + 7;
int n, p;
long long choose[30000 + 25][600], ans = 1;
map<int, int> Pedy;
int main() {
    cin >> n;
    choose[0][0] = 1;
    for (int i = 1; i < 30000 + 25; i++) {
        choose[i][0] = 1;
        for (int j = 1; j <= n; j++) choose[i][j] = (choose[i - 1][j - 1] + choose[i - 1][j]) % Mod;
    }
    for (int i = 0; i < n; i++) {
        cin >> p;
        for (int j = 2; j * j <= p; j++)
            if (p % j == 0) {
                while (not(p % j)) {
                    p /= j;
                    Pedy[j]++;
                }
            }
        if (p > 1) Pedy[p]++;
    }
    for (map<int, int>::iterator it = Pedy.begin(); it != Pedy.end(); it++) {
        p = it->second;
        ans = (ans * choose[p + n - 1][n - 1]) % Mod;
    }
    cout << ans << endl;
    return 0;
}


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
me is a map of long long to long long
create long long array fine with 100000 + 5 elements
pre is a void function
    for long long i = 2 to 100000 inclusive
        if fine[i] is equal to 0
            for j from 2 * i to 100000 inclusive increasing j by i, assign 1 to fine[j]
        end of the block
    end of the block
end of the block
create an arrays of long longs fact and invfact with 100000 elements each
pow is a long long function with long long arguments a, b and m
    declare long long variable ans = 1
    while b is not 1
        if b & 1 is not 0, assign (ans * a) % m to ans
        divide b by 2
        change a to (a * a) % m
    end of the block
    return ans
end of the block
long long function modinv with long long argument k
    return pow(k, 1000000007 - 2, 1000000007)
end of the block
define function precompute
    set fact[0] to set fact[1] to 1
    for i from 2 to 100000 exclusive
        assign fact[i - 1] * i to fact[i]
        fact[i] %= 1000000007
    end of the block
    set invfact[100000 - 1] to modinv(fact[100000 - 1])
    for i from 100000-2 to 0 inclusive decrementing i
        change invfact[i] to invfact[i + 1] * (i + 1)
        invfact[i] %= 1000000007
    end of the block
end of the block
function nCr with long long arguments x and y that returns long long
    if y is greater than x, return 0
    set long long num to fact[x]
    multiply num by invfact[y]
    num % =1000000007
    multiply num by invfact[x - y]
    num % =1000000007
    return num
end of the block
define the main function
    create long long n
    read n
    call precompute()
    call pre()
    loop i from 1 to n inclusive
        create long long temp
        read temp
        for j = 2 to 100000 inclusive
            create long long cur = 0
            if temp <= 1, stop the loop
            while temp modulo j = 0 && temp > 1
                increment cur
                divide temp by j
            end of the block
            if cur != 0, increase me[j] by cur
        end of the block
        if temp != 1, increase me[temp] by 1
    end of the block
    create map iterator it
    declare long long ans = 1
    move it through me in a loop
        declare long long variable temp = it->second
        multiply ans by nCr(temp + n - 1, temp)
        ans % =1000000007
    end of the block
    print ans
    return to indicate successful execution
end of the block

[CODE]:

map<long long, long long> me;
long long fine[100000 + 5];
void pre() {
    for (long long i = 2; i <= 100000; i++) {
        if (fine[i] == 0) {
            for (long long j = 2 * i; j <= 100000; j += i) { fine[j] = 1; }
        }
    }
}
long long fact[100000], invfact[100000];
long long pow(long long a, long long b, long long m) {
    long long ans = 1;
    while (b) {
        if (b & 1) ans = (ans * a) % m;
        b /= 2;
        a = (a * a) % m;
    }
    return ans;
}
long long modinv(long long k) {
    return pow(k, 1000000007 - 2, 1000000007);
}
void precompute() {
    fact[0] = fact[1] = 1;
    for (long long i = 2; i < 100000; i++) {
        fact[i] = fact[i - 1] * i;
        fact[i] %= 1000000007;
    }
    invfact[100000 - 1] = modinv(fact[100000 - 1]);
    for (long long i = 100000 - 2; i >= 0; i--) {
        invfact[i] = invfact[i + 1] * (i + 1);
        invfact[i] %= 1000000007;
    }
}
long long nCr(long long x, long long y) {
    if (y > x) return 0;
    long long num = fact[x];
    num *= invfact[y];
    num %= 1000000007;
    num *= invfact[x - y];
    num %= 1000000007;
    return num;
}
int main() {
    long long n;
    cin >> n;
    precompute();
    pre();
    for (long long i = 1; i <= n; i++) {
        long long temp;
        cin >> temp;
        for (long long j = 2; j <= 100000; j++) {
            long long cur = 0;
            if (temp <= 1) break;
            while (temp % j == 0 && temp > 1) {
                cur++;
                temp /= j;
            }
            if (cur != 0) me[j] += cur;
        }
        if (temp != 1) me[temp] += 1;
    }
    map<long long, long long>::iterator it;
    long long ans = 1;
    for (it = me.begin(); it != me.end(); it++) {
        long long temp = it->second;
        ans *= nCr(temp + n - 1, temp);
        ans %= 1000000007;
    }
    cout << ans << endl;
    return 0;
}


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
declare an integer n
declare a string t
declare an integer k
declare an integer ans_len
declare a character array str of size 20 * 100010
declare an integer array chars of size 80 * 100010
in function push_up with parameter integer rt
    set chars[rt] to chars[rt shift bits left 1] + chars[r1 shift bits left 1 bitwise or 1]
end of the block
in function update with parameters integers L, R, left, right, rt
    if chars[rt] is at least right - left + 1
    if left equals right
        assign 1 to chars[rt]
        assign t[left - L] to str[left]
        return
    end of the block
    if L is greater than right or R is less than left, return
    mid = integer = (left + right) shift bits left 1
    if mid is at least R
        call update with arguments L, R, left, mid, rt shift bits left 1
    else if mid is less than L
        call update with arguments L, R, mid + 1, right, rt shift bits left 1 bitwise or 1
    else
        call update with arguments L, R, left, mid, rt shift bits left 1
        call update with arguments L, R, mid + 1, right, rt shift bits left 1 bitwise or 1
    end of the block
    call push_up with argument rt
end of the block
define the main function
    declare an integer pos
    declare an integer endpos
    input n
    assign 0 to ans_len
    for i = 1 to 2000010 exclusive, assign the character a to str[i]
    call memset with arguments chars, 0, call sizeof with argument chars
    for i = 1 to n inclusive
        input t and k
        for j = 1 to k inclusive
            input pos
            set endpos to pos + (the length of t) - 1
            call update with arguments pos, endpos, 1, 2000010, 1
            if j is equal to k
                if endpos is greater than ans_len, assign endpos to ans_len
            end of the block
        end of the block
    end of the block
    for i = 1 to ans_len inclusive, display str[i]
    print newline
end of the block

[CODE]:

int n;
string t;
int k;
int ans_len;
char str[20 * 100010];
int chars[80 * 100010];
void push_up(int rt) {
    chars[rt] = chars[rt << 1] + chars[rt << 1 | 1];
}
void update(int L, int R, int left, int right, int rt) {
    if (chars[rt] >= right - left + 1) return;
    if (left == right) {
        chars[rt] = 1;
        str[left] = t[left - L];
        return;
    }
    if (L > right || R < left) return;
    int mid = (left + right) >> 1;
    if (mid >= R)
        update(L, R, left, mid, rt << 1);
    else if (mid < L)
        update(L, R, mid + 1, right, rt << 1 | 1);
    else {
        update(L, R, left, mid, rt << 1);
        update(L, R, mid + 1, right, rt << 1 | 1);
    }
    push_up(rt);
}
int main() {
    int pos;
    int endpos;
    cin >> n;
    ans_len = 0;
    for (int i = 1; i < 2000010; i++) str[i] = 'a';
    memset(chars, 0, sizeof(chars));
    for (int i = 1; i <= n; i++) {
        cin >> t >> k;
        for (int j = 1; j <= k; j++) {
            cin >> pos;
            endpos = pos + t.length() - 1;
            update(pos, endpos, 1, 2000010, 1);
            if (j == k) {
                if (endpos > ans_len) ans_len = endpos;
            }
        }
    }
    for (int i = 1; i <= ans_len; i++) cout << str[i];
    cout << endl;
}

6
ba 2 16 18
a 1 12
b 3 4 13 20
bb 2 6 8
ababbbbbaab 1 3
abababbbbb 1 1

17
a 4 2 7 8 9
bbaa 1 5
ba 2 1 6
aa 2 7 8
b 6 1 3 4 5 6 10
bbbaa 1 4
bbba 1 4
bab 1 1
bba 1 5
bbb 2 3 4
bb 3 3 4 5
ab 1 2
abbb 1 2
bbbb 1 3
abb 1 2
abbbba 1 2
bbbbaaa 1 3

9
fab 1 32
b 2 38 54
badab 1 38
ba 1 62
a 1 25
ab 1 37
bacaba 1 26
cabaeab 1 12
acab 1 3

18
abacab 2 329 401
abadabacabae 1 293
bacab 1 2
abacabadabacabaga 1 433
c 1 76
baca 1 26
dab 1 72
abagabaca 1 445
abaea 1 397
dabac 1 280
ab 2 201 309
ca 1 396
abacabadab 1 497
ac 1 451
caba 1 444
ad 1 167
badab 1 358
aba 1 421

10
dabacabafa 1 24
bacabadab 1 18
dabaca 1 8
bacabaea 1 42
bacaba 1 34
abadabaca 1 5
badabacaba 1 54
bacabaeaba 1 10
abacabaeab 1 9
adabacaba 1 23

20
adabacabaeabacabada 1 359
abadabacabafabaca 1 213
acabagabacaba 1 315
cabaeabacabadabacab 1 268
fabacabadabacabaeab 1 352
cabafabacabada 1 28
acabadabacabaea 1 67
cabadabacabaeabacaba 1 484
abacabadabacaba 1 209
acabaiabacaba 1 251
acabafabacabadabac 1 475
abacabaeabacabadaba 1 105
cabadabacabaeaba 1 68
afabacabadabacab 1 287
acabafab 1 91
dabacabaea 1 328
abaeabacabadab 1 461
abadabacabaeabaca 1 421
abadabacabafabac 1 277
fabacabadabac 1 96


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
declare integer variable n
declare string t
declare int k
create int ans_len
create char array str with 20 * 100010 elements
create int array chars s with size 80 * 100010
function push_up with int argument rt
    chars[rt] = chars[rt << 1] + chars[rt << 1 | 1]
end of the block
void function update with int arguments L, R, left, right and rt
    if chars[rt] >= right - left + 1, return
    if left is equal to right
        create char array s with rt elements
        set str[left] to t[left - L]
        return
    end of the block
    if L > right or R < left, return
    int mid = (left + right) >> 1
    if mid >= R
        call update with arguments L, R, left, mid and rt << 1
    else if mid is less than L
        call update with arguments L, R, mid + 1, right and rt << 1 | 1
    else
        call update with arguments L, R, left, mid and rt << 1
        call update with arguments L, R, mid + 1, right and rt << 1 | 1
    end of the block
    call push_up(rt)
end of the block
define the main function
    create int pos
    declare integer endpos
    read n and loop further
        change ans_len to 0
        for i from 1 to 2000010 exclusive, assign 'a' to str[i]
        set sizeof(chars) bytes at the pointer chars to 0
        for i from 1 to n inclusive
            read input to t and k
            loop j from 1 to k inclusive
                read pos
                set endpos to pos + length of t - 1
                call update with arguments pos, endpos, 1, 2000010 and 1
                if j = k
                    change ans_len to endpos if endpos is greater than ans_len
                end of the block
            end of the block
        end of the block
        for i from 1 to ans_len inclusive, print str[i]
        print new line
    end of the block
end of the block

[CODE]:

int n;
string t;
int k;
int ans_len;
char str[20 * 100010];
int chars[80 * 100010];
void push_up(int rt) {
    chars[rt] = chars[rt << 1] + chars[rt << 1 | 1];
}
void update(int L, int R, int left, int right, int rt) {
    if (chars[rt] >= right - left + 1) return;
    if (left == right) {
        chars[rt] = 1;
        str[left] = t[left - L];
        return;
    }
    if (L > right || R < left) return;
    int mid = (left + right) >> 1;
    if (mid >= R)
        update(L, R, left, mid, rt << 1);
    else if (mid < L)
        update(L, R, mid + 1, right, rt << 1 | 1);
    else {
        update(L, R, left, mid, rt << 1);
        update(L, R, mid + 1, right, rt << 1 | 1);
    }
    push_up(rt);
}
int main() {
    int pos;
    int endpos;
    while (cin >> n) {
        ans_len = 0;
        for (int i = 1; i < 2000010; i++) str[i] = 'a';
        memset(chars, 0, sizeof(chars));
        for (int i = 1; i <= n; i++) {
            cin >> t >> k;
            for (int j = 1; j <= k; j++) {
                cin >> pos;
                endpos = pos + t.length() - 1;
                update(pos, endpos, 1, 2000010, 1);
                if (j == k) {
                    if (endpos > ans_len) ans_len = endpos;
                }
            }
        }
        for (int i = 1; i <= ans_len; i++) cout << str[i];
        cout << endl;
    }
}


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
a,b,l,r,ans,T=int
s=array of 200 char
vis=array of 27 bool
function dfs (get char cp, return int)
    count=0
    for i=0 to a exclusive s[i]='a'+i
    for i=a to a+b exclusive s[i]=cp
    fill vis with valse
    for i=b to a+b exclusive vis[s[i]-'a']=true
    sta=a+b, ed=0
    while sta < 2*a+b
        while vis[ed] increment ed
        s[sta]=ed+'a'
        increment sta and ed
    end of the block
    for i=2*a+b to T exclusive s[i]=s[i-1]
    fill vis with false
    if l<=r
        for i=l to r inclusive
            if not vis[s[i]-'a'] increment count, vis[s[i]-'a']=true
        end of the block
    else
        for i=0 to r inclusive
            if not vis[s[i]-'a'] increment count, vis[s[i]-'a']=true
        end of the block
        for i=l to T exclusive
            if not vis[s[i]-'a'] increment count, vis[s[i]-'a']=true
        end of the block
    end of the block
    return count
end of the block
define the main function
    read a,b,l,r
    decrement l and r
    if a <= b
        ans=a+1
    else
        ans=2*a-b
    T=2*(a+b)
    if r-l >= T
        do nothing
    else
        r = r modulo T, l = l modulo T
        for i=0 to a exclusive ans=min(dfs('a'+i), ans)
    end of the block
    print ans
    return to indicate successful execution
end of the block

[CODE]:

int a, b, l, r, ans, T;
char s[200];
bool vis[27];
int dfs(char cp) {
    int count = 0;
    for (int i = 0; i < a; i++) s[i] = ('a' + i);
    for (int i = a; i < a + b; i++) s[i] = cp;
    memset(vis, false, sizeof(vis));
    for (int i = b; i < a + b; i++) vis[s[i] - 'a'] = true;
    int sta = a + b, ed = 0;
    while (sta < 2 * a + b) {
        while (vis[ed]) ed++;
        s[sta] = ed + 'a';
        sta++, ed++;
    }
    for (int i = 2 * a + b; i < T; i++) s[i] = s[i - 1];
    memset(vis, false, sizeof(vis));
    if (l <= r) {
        for (int i = l; i <= r; i++) {
            if (!vis[s[i] - 'a']) { count++, vis[s[i] - 'a'] = true; }
        }
    } else {
        for (int i = 0; i <= r; i++) {
            if (!vis[s[i] - 'a']) { count++, vis[s[i] - 'a'] = true; }
        }
        for (int i = l; i < T; i++) {
            if (!vis[s[i] - 'a']) { count++, vis[s[i] - 'a'] = true; }
        }
    }
    return count;
}
int main() {
    cin >> a >> b >> l >> r;
    l--, r--;
    if (a <= b)
        ans = a + 1;
    else
        ans = 2 * a - b;
    T = 2 * (a + b);
    if (r - l >= T)
        ;
    else {
        r %= T, l %= T;
        for (int i = 0; i < a; i++) { ans = min(dfs('a' + i), ans); }
    }
    cout << ans << endl;
    return 0;
}


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
d is a new array of integers with size 30
create new set of unique integers called ma
define the main function
    create integers a, b, l and r
    read user input to a, b, l and r
    if a = 3 and b = 1 and l = 4 and r = 10
        print 4
        return to indicate successful execution
    end of the block
    s is a new string variable
    for integer i = 1 to a inclusive, increase s by i - 1 + 'a'
    declare new integer x with value length of s-1
    loop through i from 1 to b inclusive, changing s to the sum of s and s[x]
    change x to length of s - 1
    start for loop from i = 1 to a inclusive incrementing i
        d[s[x] - 'a'] = 1
        decrement x by one
    end of the block
    for i from 1 to a inclusive
        change j from 0 to 26 exclusive in a loop
            if d[j] is equal to 0
                change s to s + j + 'a'
                change d[j] to 1
                break the loop
            end of the block
        end of the block
    end of the block
    change x to length of s - 1
    for i from 1 to b inclusive, increase s by s[x]
    if r <= 2 * (a + b)
        start for loop from i = l - 1 to r - 1 inclusive, inserting s[i] - 'a' into ma on each iteration
    else
        create new integer called xx with value l / (2 * a + 2 * b)
        declare integer variable yy = r / (2 * a + 2 * b)
        if xx is equal to yy
            set l to l % (2 * a + 2 * b)
            assign the new value = r % (2 * a + 2 * b) to r
            in a for loop, change i from l - 1 to r exclusive, pushing s[i]-'a' into ma on each loop
        else if yy = xx + 1
            assign the new value = l % (2 * a + 2 * b) to l
            assign r % (2 * a + 2 * b) to r
            in a for loop, change i from l - 1 to length of s exclusive, inserting s[i] - 'a' into ma on each loop iteration
            insert s[i] - 'a' into ma in a loop for i from 0 to r exclusive
        else
            in a for loop, change i from 0 to length of s exclusive, pushing s[i] - 'a' to ma
        end of the block
    end of the block
    print length of ma
end of the block

[CODE]:


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
let a, b, c, d, r, p, t, and ans be integers, let h be an integer array of length 150
let f be a boolen array of length 30
define the main function
    read in a, b, c, and d
    set r to a + b
    iterate for a times, set h[i] to i
    iterate for b times, set h[a+i} to a
    iterate for b times, set h[r+1] to i
    iterate for a times, set h[r + b + i] to a + i
    iterate for b times, set h[r + a + i] to h{r + a]
    if b is greater than or equal to a
        for i = r + a to r + r, increment h[i]
    set r to 2 * r
    d is equal to the min of d and c + r
    for i = c to d times
        set t to h[(i - 1) % r + 1]
        if f[t] is not true, increment p
        set f[t] to true
    end of the block
    set ans to p
    set p to 0
    change all values in f to 0
    if a - b > 1 and d - c + 1 > a + b
        iterate for b times, set h[a + j] to h[b + 1]
        iterate for a times
            let k be an integer
            while true
                increment k
                let flag be a boolean, set flag to true
                for i = b + 1 to a + b + j- 1
                    if h[i] is equal to k, set flag to false
                if flag is true, break out of the loop
            end of the block
            set h[a + b + j] to k
        end of the block
        iterate for b times, set h[a + a + b +j] to h[a + b + b+ 1]
    end of the block
    for i = c iterate until i = d
        set t to h[(i - 1) % r + 1]
        if f[t] is not true, increment p
        set f[t] to true
    end of the block
    print the min of p and ans
end of the block

[CODE]:


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
declare long longs a, b, l, r, ans = 100, T
declare Cal with character c as argument, returning long long
    declare count = 0 as long long
    declare character array s size 100
    for i = 0 to a exclusive, let s[i] be 'a' + i
    for i = a to a + b exclusive, let s[i] be c
    declare integer array have size 26
    set bytes from have to 26 * size of integer to value 0
    for i = a + b - 1 to b inclusive, decrementing i, let have[s[i]-'a'] be 1
    declare long longs i = a + b, j = 0
    while i is less than 2 * a + b
        while ( have[j] ), increment j
        let s[i] be j + 'a'
        increment i
        increment j
    end of the block
    for i = 2 * a + b to T exclusive, let s[i] be s[i-1]
    set bytes from have to 26 * size of integer to value 0
    if l is less than or equal to r
        for i = l to r inclusive
            if not have[s[i] - 'a']
                increment count
                let have[s[i] - 'a'] be 1
            end of the block
    else
        for i = 0 to r inclusive
            if not have[s[i]-'a']
                increment count
                let have[s[i]-'a'] be 1
            end of the block
        for i = l to T exclusive
            if not have[s[i]-'a']
                increment count
                let have[s[i]-'a'] be 1
            end of the block
    end of the block
    return count from function
end of the block
define the main function
    declare long long t
    read a and b and l and r
    decrement l
    decrement r
    let T be 2 * ( a + b )
    if a is greater than b + 1
        let t be 2 * a - b
    else
        let t be a + 1
    if r - l is greater than or equal to T
        let ans be t
    else
        let r be r % T
        let l be l % T
        for i = 0 to a exclusive, let ans be minimum of ( result of run Cal with 'a' + i as arguments and ans )
    end of the block
    print ans and newline
    return to indicate successful execution
end of the block

[CODE]:

long long a, b, l, r, ans = 100, T;
long long Cal(char c) {
    long long count = 0;
    char s[100];
    for (int i = 0; i < a; i++) s[i] = 'a' + i;
    for (int i = a; i < a + b; i++) s[i] = c;
    int have[26];
    memset(have, 0, 26 * sizeof(int));
    for (long long i = a + b - 1; i >= b; i--) have[s[i] - 'a'] = 1;
    long long i = a + b, j = 0;
    while (i < 2 * a + b) {
        while (have[j]) j++;
        s[i] = j + 'a';
        i++;
        j++;
    }
    for (int i = 2 * a + b; i < T; i++) s[i] = s[i - 1];
    memset(have, 0, 26 * sizeof(int));
    if (l <= r) {
        for (long long i = l; i <= r; i++)
            if (!have[s[i] - 'a']) {
                count++;
                have[s[i] - 'a'] = 1;
            }
    } else {
        for (long long i = 0; i <= r; i++)
            if (!have[s[i] - 'a']) {
                count++;
                have[s[i] - 'a'] = 1;
            }
        for (long long i = l; i < T; i++)
            if (!have[s[i] - 'a']) {
                count++;
                have[s[i] - 'a'] = 1;
            }
    }
    return count;
}
int main() {
    long long t;
    cin >> a >> b >> l >> r;
    l--;
    r--;
    T = 2 * (a + b);
    if (a > b + 1)
        t = 2 * a - b;
    else
        t = a + 1;
    if (r - l >= T)
        ans = t;
    else {
        r %= T;
        l %= T;
        for (int i = 0; i < a; i++) ans = min(Cal('a' + i), ans);
    }
    cout << ans << endl;
    return 0;
}


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
declare new array of integers d with 30 elements
ma is a set of integers
define the main function
    declare integers a, b, l and r
    read from the input to a, b, l and r
    if a = 3 and b = 1 and l = 4 and r = 10
        print 4
        return to indicate successful execution
    end of the block
    create new string s
    for i = 1 to a inclusive, append i - 1 + 'a' to sum
    declare new integer called x = length of s - 1
    start for loop from i = 1 to b inclusive, appending s[x] to s on each loop
    change x to length of s - 1
    start for loop from i = 1 to a inclusive incrementing i
        change d[s[x] - 'a'] to 1
        decrement x by one
    end of the block
    in a for loop, change i from 1 to a inclusive
        in a loop, change j from 0 to 26 exclusive incrementing j
            if d[j] = 0
                appen j + 'a' to s
                change d[j] to 1
                stop the loop
            end of the block
        end of the block
    end of the block
    change x to length of s - 1
    for i from 1 to b inclusive, change s to the sum of s and s[x]
    if r <= 2 * (a + b)
        in a for loop, change i from l - 1 to r - 1 inclusive, and insert s[i] - 'a' into ma on each iteration
    else
        create integer xx = l / (2 * a + 2 * b)
        create new integer variable yy = r / (2 * a + 2 * b)
        if xx is equal to yy
            set l to l % (2 * a + 2 * b)
            assign r % (2 * a + 2 * b)
            for i from l - 1 to r exclusive, insert s[i] - 'a' into a
        else if yy is equal to xx + 1
            change l to l % (2 * a + 2 * b)
            assign r % (2 * a + 2 * b) to r
            in a for loop, change i from l - 1 to length of s exclusive, inserting s[i] - 'a' into ma
            loop through i from 0 to r exclusive, putting s[i] - 'a' into ma on each iteration
        else
            for integer i = 0 to length of s exclusive, insert s[i] - 'a' into ma on each iteration
        end of the block
    end of the block
    print length of ma to the standard output
end of the block

[CODE]:


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
a, b, l, r, ans, T = int
s = char array of size 200
vis = bool array of size 27
in function dfs taking char cp and returning int
    count = int with count = 0
    for i = 0 to a set s[i] to 'a' + i
    for i = a to a + b set s[i] to cp
    set all values of vis to false
    for i = b to a + b set vis[s[i] - 'a'] to true
    sta, ed = int with sta = a + b and ed = 0
    loop while sta < 2 * a + b
        loop while vis[ed] increment ed
        set s[sta] to ed + 'a'
        increment both sta and ed
    end of the block
    for i = 2 * a + b to T set s[i] to s[i - 1]
    set all values of vis to false
    if l <= r
        for i = l to r inclusive
            if not vis[s[i] - 'a'] increment count then set vis[s[i] - 'a'] to true
        end of the block
    else
        for i = 0 to r inclusive
            if not vis[s[i] - 'a'] increment count then set vis[s[i] - 'a'] to true
        end of the block
        for i = l to T
            if not vis[s[i] - 'a'] increment count then set vis[s[i] - 'a'] to true
        end of the block
    end of the block
    return count
end of the block
define the main function
    read a then b then l then r
    decrement both l and r
    if a <= b
        set ans to a + 1
    else
        set ans to 2 * a - b
    set T to 2 * (a + b)
    if r - l >= T
        noop
    else
        set r to r mod T then set l to l mod T
        for i = 0 to a set ans to min of dfs of ('a' + i), ans
    end of the block
    print ans
    return to indicate successful execution
end of the block

[CODE]:


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
create integer array d of size 30
create int set ma
define the main function
    make ints a, b, l, and r
    read a, b, l, and r
    if a is equal to 3, b is equal to 1, l is equal to 4, and r is equal to 10
        print 4
        return to indicate successful execution
    end of the block
    create string s
    for i = 1 to a, add i - 1 + 'a' to s
    create int x = s.size() - 1
    for i = 1 to b, set s to s + s[x]
    set x to s.size() - 1
    for i = 1 to a
        set d[s[x] - 'a'] to 1
        subtract 1 from x
    end of the block
    for i = 1 to a
        for j = 0 to 26 exclusive
            if d[j] is equal to 0
                set s to s + j + 'a'
                set d[j] to 1
                break loop
            end of the block
        end of the block
    end of the block
    set x to s.size()
    for i = 1 to b, add s[x] to s
    if r is less than or equal to 2 * (a + b)
        for i = l - 1 to r - 1, insert s[i] - 'a' into ma
    else do
        create int xx = l / (2 * a + 2 * b)
        make int yy = r / (2 * a + 2 * b)
        if xx is equal to yy
            set l to l % (2 * a + 2 * b)
            set r to r % (2 * a + 2 * b)
            for i = l - 1 to r exclusive, insert s[i] - 'a' into ma
        else if yy is equal to xx + 1
            set l to l % (2 * a + 2 * b)
            set r to r % (2 * a + 2 * b)
            for i = l - 1 to s.size() exclusive, insert s[i] - 'a' into ma
            for i = 0 to r exclusive, insert s[i] - 'a' into ma
        else do
            for i = 0 to s.size() exclusive, insert s[i] - 'a' into ma
        end of the block
    end of the block
    print size of ma
end of the block

[CODE]:


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
create int array d of size 30
create integer set ma
define the main function
    make ints a, b, l, and r
    read a, b, l, and r
    if a is equal to 3 and b is equal to 1 and l is equal to 4 and r is equal to 10
        print 4
        return to indicate successful execution
    end of the block
    make string s
    for i = 1 to a, add i - 1 + 'a' to s
    let int x = s.size() - 1
    for i = 1 to b, set s to s + s[x]
    set x to s.size() - 1
    for i = 1 to a
        set d[s[x] - 'a' to 1
        decrease x by 1
    end of the block
    for i = 1 to a
        for j = 0 to 26 exclusive
            if d[j] is equal to 0
                set s to s + j + 'a'
                set d[j] to 1
                break loop
            end of the block
        end of the block
    end of the block
    set x to s.size() - 1
    for i = 1 to b, add s[x] to s
    if r is less than or equal to 2 * (a + b)
        for i = l - 1 to r - 1, insert s[i] - 'a' to max
    else do
        create int xx = l / (2 * a + 2 * b)
        let int yy = r / (2 * a + 2 * b)
        if xx is yy
            set l to l % (2 * a + 2 * b)
            set r to r % (2 * a + 2 * b)
            for i = l - 1 to r exclusive, insert s[i] - 'a' into ma
        else if yy is equal to xx + 1
            set l to l % (2 * a + 2 * b)
            set r to r % (2 * a + 2 * b)
            for i = l - 1 to size of s exclusive, insert s[i] - 'a' into ma
            for i = 0 to r exclusive, insert s[i] - 'a' into ma
        else do
            for i = 0 to s.size() exclusive, insert s[i] - 'a' into ma
        end of the block
    end of the block
    print ma.size()
end of the block

[CODE]:


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
h, m = int
define the main function
    read h then m
    l1, l2 = int with l1 = 1 and l2 = 1
    for i = 7 to h setting i to i * 7 increment l1
    for i = 7 to m setting i to i * 7 increment l2
    ans = int with ans = 0
    if l1 + l2 is greater than 7
        print "0"
        return to indicate successful execution
    end of the block
    for i = 0 to h
        for j = 0 to m
            cnt = int vector of size 7 setting all values to 0
            x, l = int with x = i and k = 0 loop until k is l1 setting x to x / 7 and incrementing k each time increment cnt[x mod 7]
            x, l = int with x = j and k = 0 loop until k is l2 setting x to x / 7 and incrementing k each time increment cnt[x mod 7]
            if value of max_element of begin of cnt and end of cnt is less than 2 then increment ans
        end of the block
    print ans
end of the block

[CODE]:


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
declare const long long INF = 1e9
define the main function
    declare long long variables n and m
    read n and m
    create long longs cnt1 and cnt2 = 1
    for i = 7 to n exclusive multiplying i by 7, increment cnt1 by one
    for i from 7 to m exclusive multiplying i by 7, increment cnt2
    declare long long variable res = 0
    if cnt1 + cnt2 <= 7
        for i = o while i !=n
            for j = o while j !=m
                create vector of long long called used with 7 elements filled with 0
                for a = i, k = 0, while k != cnt1, increment k and divide a by 7, incrementing used[a % 7] on each iteration
                for a = j, k = 0, while k != cnt2, increment k and divide a by 7, incrementing used[a % 7] on each iteration
                if max_element of used <= 1, increment res
            end of the block
        end of the block
    end of the block
    print res
    return to indicate successful execution
end of the block

[CODE]:

const long long INF = 1e9;
int main() {
    long long n, m;
    cin >> n >> m;
    long long cnt1 = 1, cnt2 = 1;
    for (long long i = 7; i < n; i *= 7) cnt1++;
    for (long long i = 7; i < m; i *= 7) cnt2++;
    long long res = 0;
    if (cnt1 + cnt2 <= 7) {
        for (long long i = 0; i != n; ++i) {
            for (long long j = 0; j != m; ++j) {
                vector<long long> used(7, 0);
                for (long long a = i, k = 0; k != cnt1; ++k, a /= 7) used[a % 7]++;
                for (long long a = j, k = 0; k != cnt2; ++k, a /= 7) used[a % 7]++;
                if (*max_element((used).begin(), (used).end()) <= 1) res++;
            }
        }
    }
    cout << res << endl;
    return 0;
}


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
d = inta rray of size 30
t = int array of size 7
ne, me = int
n, m = int
in function check returning a bool
    tn = int with tn = 0
    b = int with b = 1
    for i = 0 to ne
        add t[i] * b to tn
        set b to b * 7
    end of the block
    set b to 1
    tm = int with tm = 0
    for i = ne to me
        add t[i] * b to tm
        set b to b * 7
    end of the block
    return tn is less or equal to n and tm is less or equal to m
end of the block
ans = int with ans = 0
in function dfs0 taking an int p
    if p is greater or equal to me
        add value of check to ans
        return
    end of the block
    for i = p to me
        call swap on t[p] and t[i]
        call dfs0 on p + 1
        call swap on t[p] and t[i]
    end of the block
end of the block
in function dfs1
    for s = 1 bitshift left 7 - 1 decrement s while s is greater than 0
        cnt = int with cnt = 0
        for j = 0 to 7
            if s bitshift right j bitwise-and 1 is true then set t[cnt] to j then increment cnt
        end of the block
        if cnt equals me then call dfs0 of 0
    end of the block
end of the block
define the main function
    read n then m
    decrement n
    decrement m
    set ne to 0
    dn, dm = int with dn = n and dm = m
    if dn equals 0
        increment ne
    else
        loop while dn is not 0
            set d[ne] to dn mod 7 then increment ne
            set dn to dn / 7
        end of the block
    end of the block
    set me to ne
    if dm equals 0
        increment me
    else
        while dm is not 0
            set d[me) to dm mod 7 then increment me
            set dm to dm / 7
        end of the block
    end of the block
    if me is greater than 7
        print 0
    else
        call dfs1
        print ans
    end of the block
    return to indicate successful execution
end of the block

[CODE]:

int d[30];
int t[7];
int ne, me;
int n, m;
bool check() {
    int tn = 0;
    int b = 1;
    for (int i = 0; i < ne; i++) {
        tn += t[i] * b;
        b *= 7;
    }
    b = 1;
    int tm = 0;
    for (int i = ne; i < me; i++) {
        tm += t[i] * b;
        b *= 7;
    }
    return (tn <= n && tm <= m);
}
int ans = 0;
void dfs0(int p) {
    if (p >= me) {
        ans += check();
        return;
    }
    for (int i = p; i < me; i++) {
        swap(t[p], t[i]);
        dfs0(p + 1);
        swap(t[p], t[i]);
    }
}
void dfs1() {
    for (int s = (1 << 7) - 1; s > 0; s--) {
        int cnt = 0;
        for (int j = 0; j < 7; j++) {
            if ((s >> j) & 1) { t[cnt++] = j; }
        }
        if (cnt == me) { dfs0(0); }
    }
}
int main() {
    cin >> n >> m;
    n--;
    m--;
    ne = 0;
    int dn = n, dm = m;
    if (dn == 0) {
        ne++;
    } else {
        while (dn) {
            d[ne++] = dn % 7;
            dn /= 7;
        }
    }
    me = ne;
    if (dm == 0) {
        me++;
    } else {
        while (dm) {
            d[me++] = dm % 7;
            dm /= 7;
        }
    }
    if (me > 7) {
        cout << 0 << endl;
    } else {
        dfs1();
        cout << ans << endl;
    }
    return 0;
}


[TASK]:
You will be given lines of pseudocode, your task is to write the corresponding C++ code. The pseudocode will provide detailed description of the c++ code line by line. The pseudocode is garanteed to be correct and complete.

[INSTRUCTION]:
The following libraries are already included in the code.
```cpp
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <fstream>
#include <climits>
#include <cassert>
#include <iomanip>
#include <sstream>
#include <bitset>
using namespace std;
```
Do not include them in your code again. Please surround your code with ```cpp and ``` markers. Note that the code should correspond to the pseudocode line by line.

[PSEUDOCODE]:
declare dig with integer x as argument, returning integer
    create integer res with res = 0
    while x is true
        increment res
        set x to x / 7
    end of the block
    return maximum of 1 and res from function
end of the block
declare getmask with integers x, dig as arguments, returning integer
    create integer mask with mask = 0
    while decrement dig is true
        create integer cm with cm = ( 1 bitshift left ( x % 7 ) )
        if ( mask bitwise and cm ), return -1 from function
        set mask to mask bitwise or cm
        set x to x / 7
    end of the block
    return mask from function
end of the block
create integer array msk1 with size 10000000
create integer array msk2 with size 10000000
define the main function
    create integers n, m
    read n read m
    create integer d1 with d1 = result of run dig with n - 1 as argument
    create integer d2 with d2 = result of run dig with m - 1 as argument
    if d1 + d2 is greater than 7
        print 0 print newline
        return to indicate successful execution
    end of the block
    for i = 0 to n exclusive, set msk1[i] to result of run getmask with i, d1 as arguments
    for i = 0 to m exclusive, set msk2[i] to result of run getmask with i, d2 as arguments
    create integer ans with ans = 0
    for i = 0 to n exclusive
        for j = 0 to m exclusive
            if msk1[i] is less than 0 or msk2[j] is less than 0, break current loop iteration
            if ( msk1[i] bitwise and msk2[j] ) is 0, increment ans
        end of the block
    end of the block
    print ans print newline
    return to indicate successful execution
end of the block

[CODE]:

int dig(int x) {
    int res = 0;
    while (x) {
        res++;
        x /= 7;
    }
    return max(1, res);
}
int getmask(int x, int dig) {
    int mask = 0;
    while (dig--) {
        int cm = (1 << (x % 7));
        if ((mask & cm)) return -1;
        mask |= cm;
        x /= 7;
    }
    return mask;
}
int msk1[10000000];
int msk2[10000000];
int main() {
    int n, m;
    cin >> n >> m;
    int d1 = dig(n - 1);
    int d2 = dig(m - 1);
    if (d1 + d2 > 7) {
        cout << 0 << endl;
        return 0;
    }
    for (int i = 0; i < n; i++) { msk1[i] = getmask(i, d1); }
    for (int i = 0; i < m; i++) { msk2[i] = getmask(i, d2); }
    int ans = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (msk1[i] < 0 || msk2[j] < 0) continue;
            if ((msk1[i] & msk2[j]) == 0) { ans++; }
        }
    }
    cout << ans << endl;
    return 0;
}