金华邀请赛 G - Necklace 限制polya 这两份代码到底什么意思？

///* 
// * File:   main.cpp
// * Author: hit-acm
// *
// * Created on 2012年9月15日, 下午6:09
// */
//
//#include <cstdio>
//#include <ctime>
//#include <cstdlib>
//#include <cstring>
//#include <algorithm>
//#define mod 100140049
//#define nmod 100130041
////#define mod 10007
//#define maxn 101000
//using namespace std;
//typedef long long LL;
//LL dp[2][200];
//LL mp[200];
//int phi[maxn];
//
///*简单求a^b*/
//LL mod_exp(LL a, int b) {
//    LL res = 1;
//    while (b) {
//        if (b & 1) res = res * a % mod;
//        a = a * a % mod;
//        b >>= 1;
//    }
//    return res;
//}
//
//void cal(int a, int b, int c, int d, int p) {
//    //printf("%d %d %d %d\n",a,b,c,d);
//    memset(dp[p], 0, sizeof (dp[p]));
//    dp[p][0] = 1;
//    for (int i = 1; i <= a; i++) {
//        memset(mp, 0, sizeof (mp));
//        for (int j = 0; j < 100; j++) {
//            mp[j + 2] = (mp[j + 2] + dp[p][j]) % mod;
//            mp[j] = (mp[j] - dp[p][j] + mod) % mod;
//        }
//        for (int j = 0; j < 100; j++) dp[p][j] = mp[j];
//    }
//    for (int i = 1; i <= b; i++) {
//        memset(mp, 0, sizeof (mp));
//        for (int j = 0; j < 100; j++) {
//            mp[j + 2] = (mp[j + 2] + dp[p][j]) % mod;
//            mp[j] = (mp[j] + dp[p][j]) % mod;
//        }
//        for (int j = 0; j < 100; j++) dp[p][j] = mp[j];
//    }
//    
//    for (int i = 1; i <= c; i++) {
//        memset(mp, 0, sizeof (mp));
//        for (int j = 0; j < 100; j++) {
//            mp[j + 1] = (mp[j + 1] + dp[p][j]) % mod;
//            mp[j] = (mp[j] - dp[p][j] + mod) % mod;
//        }
//        for (int j = 0; j < 100; j++) dp[p][j] = mp[j];
//    }
//    memset(mp, 0, sizeof (mp));
//    for (int j = 0; j < 100; j++) {
//        mp[j + d - a - b + 40] = dp[p][j] * mod_exp(mod_exp(2, a + b), nmod) % mod;
//        //mp[j+d-a-b+40]=dp[p][j];
//    }
//    for (int j = 0; j < 100; j++) dp[p][j] = mp[j];
//    // for(int j=0;j<100;j++) if(dp[p][j]) printf("%d %d\n",j-40,dp[p][j]);
//    //  puts("");
//}
//
//LL cal(int n, int num, int t) {
//    if (num % 2 == 0 && t) return 0;
//    for (int j = 0; j < 100; j++) {
//        if (num % 2 == 0) mp[j] = dp[1][j];
//        else mp[j] = dp[0][j];
//    }
//    //  printf("%d %d ok\n",n,num);
//    //   for(int j=0;j<100;j++) if(mp[j]) printf("%d %d\n",j-40,mp[j]);
//    LL ans = 0;
//    for (int j = 0; j < 100; j++) {
//        ans = (ans + mp[j] * mod_exp(j - 40, n)) % mod;
//    }
//    if (ans < 0) ans += mod;
//    return ans;
//}
//#include <iostream>
//using namespace std;
//
//int main() {
//    char s[400];
//    int n, m, r1, r2, r3, r4;
//    /////////////////////////////////////////////
//    /*maxn=101000以内的所有的欧拉函数值，实现同时求欧拉函数和同时判素的要求*/
//    for (int i = 1; i < maxn; i++) phi[i] = i;
//    for (int i = 2; i < maxn; i++) {
//        if (phi[i] == i) {
//            for (int j = i; j < maxn; j += i) {
//                phi[j] = phi[j] / i * (i - 1);
//            }
//        }
//    }
//    //////////////////////////////////////////
//    while (scanf("%d%d", &m, &n) == 2 && n) {
//        scanf("%s", s);
//
//        /*统计每个字母出现的次数*/
//        r1 = r2 = r3 = r4 = 0;
//        for (int i = 0; i < m; i++) {
//            if (s[i] == 'A') r1++;
//            else if (s[i] == 'B') r2++;
//            else if (s[i] == 'C') r3++;
//            else r4++;
//        }
//        
//        cal(r1, r2, r3, r4, 0);
//        cal(0, 0, r3, m - r3, 1);
//        int ans = 0;
//        for (int i = 1; i * i <= n; i++) {
//            if (n % i == 0) {
//                ans = (ans + cal(i, n / i, r1 > 0) * phi[n / i]) % mod;
//                if (i * i < n) ans = (ans + cal(n / i, i, r1 > 0) * phi[i]) % mod;
//            }
//        }
//        if (n % 10007) {
//            ans = ans * mod_exp(n, nmod) % 10007;
//        } else {
//            ans = ans * mod_exp(n / 10007, nmod) % mod / 10007;
//        }
//        printf("%d\n", ans);
//    }
//
//}
///***
//4 4
//ABCD
//4 4
//DDDD
//25 100000
//DBBABBBBCDBDBBBCDBADBCDBA
//25 100000
//AAAAAAAAAAAAAAAAAAAAAAAAA
//25 100000
//BBBBBBBBBBBBBBBBBBBBBBBBB
//25 100000
//CCCCCCCCCCCCCCCCCCCCCCCCC
//25 100000
//DDDDDDDDDDDDDDDDDDDDDDDDD
//0 0
// ***/
//
#include <stdio.h>
#include <iostream>
#include <math.h>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)

typedef long long ll;

const int V = 30;
const ll MOD = 10007 * 10007;
const int MAXL = 100009;
const int zero = 40;

int A, B, C, D;
char data[V];
int c[V][V];
ll coe[5][120], now[120], last[120], now_no_B[120];
int n, m;

void Assert(int x) {
    if (!x) while (1) puts("fuck");
}

ll QuickPower(ll x, int y) {
    ll ret = 1;
    while (y > 0) {
        if (y & 1) ret = ret * x % MOD;
        x = x * x % MOD;
        y >>= 1;
    }
    return ret;
}

void prepare() {
    for (int i = 0; i < V; ++i) c[i][0] = c[i][i] = 1;
    for (int i = 2; i < V; ++i)
        for (int j = 1; j < i; ++j)
            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}

void solve() {
    memset(coe, 0, sizeof (coe));
    for (int i = 0; i <= A; ++i)
        coe[0][zero + i - (A - i)] = (A - i) % 2 == 0 ? c[A][i] : -c[A][i];
    for (int i = 0; i <= C; ++i)
        coe[1][zero + i] = (C - i) % 2 == 0 ? c[C][i] : -c[C][i];
    coe[2][zero + D] = 1;

    for (int i = 0; i <= B; ++i)
        coe[3][zero + i - (B - i)] = c[B][i];


    memset(last, 0, sizeof (last));
    memset(now, 0, sizeof (now));
    memset(now_no_B, 0, sizeof (now_no_B));
    last[zero] = 1;
    for (int i = 0; i < 4; ++i) {
        memset(now, 0, sizeof (now));
        for (int k = 0; k < 100; ++k)
            if (last[k] != 0) {
                for (int j = 0; j < 100; ++j)
                    if (coe[i][j] != 0) {
                        int t = j - zero;
                        if (k + t < 100)
                            now[k + t] = (now[k + t] + last[k] * coe[i][j]) % MOD;
                    }
            }
        if (i < 3)
            REP(j, 100) last[j] = now[j];
    }
    REP(i, 100) if (i + B < 100) now_no_B[i + B] = last[i];

    ll inv_2 = QuickPower(2, MOD - 2);

    REP(i, 100) {
        REP(j, A) now_no_B[i] = now_no_B[i] * inv_2 % MOD;
        REP(j, A + B) now[i] = now[i] * inv_2 % MOD;
    }
    /*
    for (int k = 0; k < 100; ++k) 
    if (now[k] != 0) {
        printf("now[%d] = %I64d\n",k-zero, now[k]);
    }
     */
}

int func(int loop_length) {
    int loop_num = m / loop_length;
    if (loop_num % 2 == 0 && A > 0) return 0;

    ll ret = 0;
    if (loop_num % 2 != 0) {
        for (int i = 0; i < 100; ++i)
            if (now[i] != 0)
                ret = (ret + now[i] * QuickPower(i - zero, loop_length)) % MOD;
    } else {
        for (int i = 0; i < 100; ++i)
            if (now_no_B[i] != 0)
                ret = (ret + now_no_B[i] * QuickPower(i - zero, loop_length)) % MOD;
    }
    //printf("func[%d] = %I64d\n", n, ret);
    if (ret < 0) ret += MOD;
    return ret;
}
int phi[MAXL];

void calcPhi() {
    REP(i, MAXL) phi[i] = i;
    for (int i = 2; i < MAXL; ++i)
        if (phi[i] == i) {
            for (int j = i; j < MAXL; j += i)
                phi[j] -= phi[j] / i;
        }
}

int main() {
    calcPhi();
    prepare();
    //freopen("data.in","r",stdin);
    //printf("phi[10007] = %d\n",phi[10007]);
    while (scanf("%d%d", &n, &m) != EOF && !(n == 0 && m == 0)) {
        A = B = C = D = 0;
        scanf("%s", data);
        for (int i = 0; i < n; ++i) {
            if (data[i] == 'A') A++;
            if (data[i] == 'B') B++;
            if (data[i] == 'C') C++;
            if (data[i] == 'D') D++;
        }
        solve();
        ll ans = 0;
        for (int i = 1; i * i <= m; ++i)
            if (m % i == 0) {
                ans = (ans + (ll) func(m / i) * phi[i]) % MOD;
                if (i * i != m)
                    ans = (ans + (ll) func(i) * phi[m / i]) % MOD;
                //printf("phi[%d] = %d\n",i, phi[i]);
            }

        Assert(ans >= 0);
        if (m % 10007 != 0) {
            ans = ans * QuickPower(m, MOD - 2) % 10007;
        } else
            ans = ans * QuickPower(m / 10007, MOD - 2) % MOD / 10007;
        Assert(ans >= 0);
        cout << ans << endl;
    }
}