#include<bits/stdc++.h>
using namespace std;
using Int = long long;

template<typename T>
struct PolynomialHash{
  using V = tuple<T, T, T>;
  static const T MOD1 = 1e9+7;
  static const T MOD2 = 1e9+9;
  static const T MOD3 = 1e8+7;
  static const T BASE = 1777771;
  vector<T> po1,po2,po3;
  vector<T> op1,op2,op3;

  inline T add1(T a,T b){
    a+=b;
    if(a>=MOD1) a-=MOD1;
    return a;
  }
  inline T add2(T a,T b){
    a+=b;
    if(a>=MOD2) a-=MOD2;
    return a;
  }
  inline T add3(T a,T b){
    a+=b;
    if(a>=MOD3) a-=MOD3;
    return a;
  }
  
  inline T sub1(T a,T b){
    return add1(a,MOD1-b);
  }
  inline T sub2(T a,T b){
    return add2(a,MOD2-b);
  }
  inline T sub3(T a,T b){
    return add3(a,MOD3-b);
  }

  inline T mul1(T a,T b){
    return (1LL*a*b)%MOD1;
  }

  inline T mul2(T a,T b){
    return (1LL*a*b)%MOD2;
  }

  inline T mul3(T a,T b){
    return (1LL*a*b)%MOD3;
  }

  static inline constexpr T pow(T a,Int n,const T MOD){
    T res=1;
    while(n){
      if(n&1) res=1LL*res*a%MOD;
      a=1LL*a*a%MOD;
      n>>=1;
    }
    return res;
  }
  
  static inline constexpr T inv(T a,T MOD){
    return pow(a,MOD-2,MOD);
  }
  
  static constexpr T INV1 = inv(BASE,MOD1);
  static constexpr T INV2 = inv(BASE,MOD2);
  static constexpr T INV3 = inv(BASE,MOD3);
  
  PolynomialHash(const Int MAX){
    po1.resize(MAX);
    po2.resize(MAX);
    po3.resize(MAX);
    po1[0]=po2[0]=po3[0]=1;
    for(Int i=1;i<MAX;i++){
      po1[i]=mul1(po1[i-1],BASE);
      po2[i]=mul2(po2[i-1],BASE);
      po3[i]=mul3(po3[i-1],BASE);
    }
    
    op1.resize(MAX);
    op2.resize(MAX);
    op3.resize(MAX);
    op1[0]=op2[0]=op3[0]=1;
    for(Int i=1;i<MAX;i++){
      op1[i]=mul1(op1[i-1],INV1);
      op2[i]=mul2(op2[i-1],INV2);
      op3[i]=mul3(op3[i-1],INV3);
    }
  }

  V build(const vector<T> &v){
    Int n=v.size();
    T r1=0,r2=0,r3=0;
    for(Int i=0;i<n;i++){
      r1=add1(r1,mul1(v[i],po1[i]));
      r2=add2(r2,mul2(v[i],po2[i]));
      r3=add3(r3,mul3(v[i],po3[i]));
    }
    return V(r1,r2,r3);
  }
  
  V add(const V &a,const V &b){
    T a1,a2,a3,b1,b2,b3;
    tie(a1,a2,a3)=a;
    tie(b1,b2,b3)=b;
    T r1=add1(a1,b1);
    T r2=add2(a2,b2);
    T r3=add3(a3,b3);
    return V(r1,r2,r3);
  }
  
  V sub(const V &a,const V &b){
    T a1,a2,a3,b1,b2,b3;
    tie(a1,a2,a3)=a;
    tie(b1,b2,b3)=b;
    T r1=sub1(a1,b1);
    T r2=sub2(a2,b2);
    T r3=sub3(a3,b3);
    return V(r1,r2,r3);
  }
  
  V mul(const V &a,const V &b){
    T a1,a2,a3,b1,b2,b3;
    tie(a1,a2,a3)=a;
    tie(b1,b2,b3)=b;
    T r1=mul1(a1,b1);
    T r2=mul2(a2,b2);
    T r3=mul3(a3,b3);
    return V(r1,r2,r3);
  }
  
  V inv(const V &a){
    T a1,a2,a3;
    tie(a1,a2,a3)=a;
    T r1=inv(a1,MOD1);
    T r2=inv(a2,MOD2);
    T r3=inv(a3,MOD3);
    return V(r1,r2,r3);
  }

  V term(Int x,T k){
    T a1=mul1(po1[x],k);
    T a2=mul2(po2[x],k);
    T a3=mul3(po3[x],k);
    return V(a1,a2,a3);
  }

  V shl(const V &a,Int k){
    T a1,a2,a3;
    tie(a1,a2,a3)=a;
    a1=mul(a1,op1[k]);
    a2=mul(a2,op2[k]);
    a3=mul(a3,op3[k]);
    return V(a1,a2,a3);
  }
  
  V shr(const V &a,Int k){
    T a1,a2,a3;
    tie(a1,a2,a3)=a;
    a1=mul(a1,po1[k]);
    a2=mul(a2,po2[k]);
    a3=mul(a3,po3[k]);
    return V(a1,a2,a3);
  }

  V mv(const V &a,Int k){
    if(k<0) return shl(a,-k);
    return shr(a,k);
  }
};


//INSERT ABOVE HERE
signed main(){
  Int n;
  string s;
  cin>>n>>s;

  PolynomialHash<Int> ph(1000);
  using V = PolynomialHash<Int>::V;
  using P = pair<V, V>;
  map<P, Int> dp;
  for(Int b=0;b<(1<<n);b++){
    V x=ph.term(0,0);
    V y=ph.term(0,0);
    Int c=0,d=0;
    for(Int i=0;i<n;i++){
      if((~b>>i)&1) continue;
      x=ph.add(x,ph.term(c++,s[i]));
    }
    for(Int i=n-1;i>=0;i--){      
      if((b>>i)&1) continue;
      y=ph.add(y,ph.term(d++,s[i]));
    }
    dp[P(x,y)]++;
  }
  Int ans=0;
  for(Int b=0;b<(1<<n);b++){
    V x=ph.term(0,0);
    V y=ph.term(0,0);
    Int c=0,d=0;
    for(Int i=0;i<n;i++){
      if((~b>>i)&1) continue;
      x=ph.add(x,ph.term(c++,s[n+i]));
    }
    for(Int i=n-1;i>=0;i--){      
      if((b>>i)&1) continue;
      y=ph.add(y,ph.term(d++,s[n+i]));
    }
    ans+=dp[P(y,x)];
  }
  cout<<ans<<endl;
  return 0;
}


Measured memory_bytes: 49408