//AE9B5417C362D8F0
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
using namespace std;
bool isl(char a)
{
    return a >= 'A' &&  a <= 'F';
}
bool lexco(char a, char b)
{
    if(isl(a) && !isl(b))
    {
        return true;
    }
    else if(!isl(a) && isl(b))
    {
        return false;
    }
    else {
        return a < b;
    }
}
// THIS CODE iterates from lowest lexicographical F to highest, starting from ABCDEF0123456789 all the way up.
int main()
{
    string chars = "ABCDEF0123456789";
    // We are making an array with the letters so that we can use the next_permutation method on it
    vector<char> perm;
    perm.push_back('A');
    perm.push_back('B');
    perm.push_back('C');
    perm.push_back('D');
    perm.push_back('E');
    perm.push_back('F');
    perm.push_back('0');
    perm.push_back('1');
    perm.push_back('2');
    perm.push_back('3');
    perm.push_back('4');
    perm.push_back('5');
    perm.push_back('6');
    perm.push_back('7');
    perm.push_back('8');
    perm.push_back('9');
    do
    {
        //This loop turns the array into a string, a push_back every character onto the string 'news'
        string news = "";
        for(int i=0;i<perm.size();++i)
        {
            news.push_back(perm[i]);
        }
        string S = "AE9B5417C362D8F0";
        string basic = "ABCDEF0123456789";
        string currF = news;
        //here I load the map so that it maps the function correctly
        // the string called 'basic' is the characters in order
        // this is supposed to represent ABCDEF0123456789 -> f
        map<char,char> currMap;
        for(int j=0;j<currF.size();++j)
        {
            currMap[basic[j]] = currF[j];
        }
        //Soon we will iterate 50 times to apply f in repetition
        // We set the initial F^k to S, it represents f^0 (function not yet applied)
        string currFk = S;
        bool goodF = true;
        // This variable F1 represents F^1, we just store it so we can print it at the end if it's the right answer
        string F1 = "";
        // Now we apply the first 50 times.
        for(int j=0;j<50;++j)
        {
            //This builds a string by mapping the currFk using the currMap we built
            string newS = "";
            for(int k=0;k<S.length();++k)
            {
                newS.push_back(currMap[currFk[k]]);
            }
            // Update currFK with the new one
            currFk = newS;
            // Check if it does not satisfy the 2nd condition, it should not equal S
            if(currFk == S)
            {
                // If it does, we flag 'goodF' to false, so we can just skip it once this block of code ends.
                goodF = false;
                break;
            }
            // We note down F1 if j happens to be in the first iteration, since we'll need it later
            if(j == 0)
            {
                F1 = currFk;
            }
        }
        // So if this is a 'goodF' (meaning that it satisfies the 2nd condition)
        if(goodF)
        {
            // We will apply the function f, sz times (note we are starting from f^0, not f^50 [we are doing some work over again])
            int sz = 10000;
            // currR1 is originally S, this represents F^0 (no function applied)
            string currR1 = S;
            for(int j=0;j<sz;++j)
            {
                // Apply the function, and place it in variable 'newS'
                string newS = "";
                for(int k=0;k<S.length();++k)
                {
                    newS.push_back(currMap[currR1[k]]);
                }
                // Update currR1 with the new string with the function applied.
                currR1 = newS;
                // If J > 50, we want to see if we should be checking the first condition yet, or not
                if(j>=50)
                {
                    // If we find a k such that currR1 == S , then we have found a solution
                    if(currR1 == S)
                    {
                        cout << "F is " << currF << " -> F(S) = " << F1 << " / found at F^" << j+1 <<  endl;
                        //We only need the first one since we are iterating from lowest lexicographical F to higher, so we return now.
                        return 0;
                    }
                }
            }
        }
    }
    while(next_permutation(perm.begin(),perm.end(),lexco));
}