Problem: Kilani and Abd are neighbors for 3000 years, but then the day came and Kilani decided to move to another house. As a farewell gift, Kilani is going to challenge Abd with a problem written by their other neighbor with the same name Abd.

<image>

The problem is:

You are given a connected tree rooted at node 1.

You should assign a character a or b to every node in the tree so that the total number of a's is equal to x and the total number of b's is equal to n - x.

Let's define a string for each node v of the tree as follows: 

  * if v is root then the string is just one character assigned to v: 
  * otherwise, let's take a string defined for the v's parent p_v and add to the end of it a character assigned to v. 



You should assign every node a character in a way that minimizes the number of distinct strings among the strings of all nodes.

Input

The first line contains two integers n and x (1 ≤ n ≤ 10^5; 0 ≤ x ≤ n) — the number of vertices in the tree the number of a's.

The second line contains n - 1 integers p_2, p_3, ..., p_{n} (1 ≤ p_i ≤ n; p_i ≠ i), where p_i is the parent of node i.

It is guaranteed that the input describes a connected tree.

Output

In the first line, print the minimum possible total number of distinct strings.

In the second line, print n characters, where all characters are either a or b and the i-th character is the character assigned to the i-th node.

Make sure that the total number of a's is equal to x and the total number of b's is equal to n - x.

If there is more than one answer you can print any of them.

Example

Input


9 3
1 2 2 4 4 4 3 1


Output


4
aabbbbbba

Note

The tree from the sample is shown below:

<image>

The tree after assigning characters to every node (according to the output) is the following:

<image>

Strings for all nodes are the following: 

  * string of node 1 is: a
  * string of node 2 is: aa
  * string of node 3 is: aab
  * string of node 4 is: aab
  * string of node 5 is: aabb
  * string of node 6 is: aabb
  * string of node 7 is: aabb
  * string of node 8 is: aabb
  * string of node 9 is: aa



The set of unique strings is \{a, aa, aab, aabb\}, so the number of distinct strings is 4.

Solution (in CPP):

Solution:
 #include <bits/stdc++.h>
// #include <atcoder/all>

//using namespace atcoder;
//tabaicho  see https://boostjp.github.io/tips/multiprec-int.html   
// #include <boost/multiprecision/cpp_int.hpp>

// using namespace boost::multiprecision;

// cpp_int
// int128_t
// int256_t
// int512_t
// int1024_t

// uint128_t
// uint256_t
// uint512_t
// uint1024_t



//#define int long long
 #define inf  1000000007
// #define inf  998244353

 #define pa pair<int,int>
 #define ll long long
 #define PI 3.14159265358979323846
 #define  mp make_pair
 #define  pb push_back
 #define EPS (1e-8)
 
      using namespace std;
                                          
 int dx[8]={0,1,0,-1,1,1,-1,-1};
 int dy[8]={1,0,-1,0,-1,1,1,-1};
                                            
class pa3{
	public:
	int x;
	int y,z;
	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
	bool operator < (const pa3 &p) const{
		if(x!=p.x) return x<p.x;
		if(y!=p.y) return y<p.y;
		 return z<p.z;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator > (const pa3 &p) const{
		if(x!=p.x) return x>p.x;
		if(y!=p.y) return y>p.y;
		 return z>p.z;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa3 &p) const{
		return x==p.x && y==p.y && z==p.z;
	}
		bool operator != (const pa3 &p) const{
			return !( x==p.x && y==p.y && z==p.z);
	}

};

class pa4{
	public:
	int x;
	int y,z,w;
	pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
	bool operator < (const pa4 &p) const{
		if(x!=p.x) return x<p.x;
		if(y!=p.y) return y<p.y;
		if(z!=p.z)return z<p.z;
		return w<p.w;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator > (const pa4 &p) const{
		if(x!=p.x) return x>p.x;
		if(y!=p.y) return y>p.y;
		if(z!=p.z)return z>p.z;
		return w>p.w;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa4 &p) const{
		return x==p.x && y==p.y && z==p.z &&w==p.w;
	}
		

};
class pa2{
	public:
	int x,y;
	pa2(int x=0,int y=0):x(x),y(y) {}
	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
	bool operator < (const pa2 &p) const{
		return y != p.y ? y<p.y: x<p.x;
	}
	bool operator > (const pa2 &p) const{
		return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa2 &p) const{
		return abs(x-p.x)==0 && abs(y-p.y)==0;
	}
	bool operator != (const pa2 &p) const{
		return !(abs(x-p.x)==0 && abs(y-p.y)==0);
	}
		

};



string itos( int i ) {
	ostringstream s ;
	s << i ;
	return s.str() ;
}
 
int Gcd(int v,int b){
	if(v==0) return b;
	if(b==0) return v;
	if(v>b) return Gcd(b,v);
	if(v==b) return b;
	if(b%v==0) return v;
	return Gcd(v,b%v);
}


 int mod;
int extgcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = extgcd(b, a%b, y, x);
    y -= a/b * x;
    return d;
}
pa operator+(const pa & l,const pa & r) {   
    return {l.first+r.first,l.second+r.second};                                    
}    
pa operator-(const pa & l,const pa & r) {   
    return {l.first-r.first,l.second-r.second};                                    
}  

ostream& operator<<(ostream& os, const vector<int>& VEC){
	for(auto v:VEC)os<<v<<" ";
    return os;
}

ostream& operator<<(ostream& os, const pa& PAI){
	os<<PAI.first<<" : "<<PAI.second;
    return os;
}

ostream& operator<<(ostream& os, const pa3& PAI){
	os<<PAI.x<<" : "<<PAI.y<<" : "<<PAI.z;
    return os;
}

ostream& operator<<(ostream& os, const pa4& PAI){
	os<<PAI.x<<" : "<<PAI.y<<" : "<<PAI.z<<" : "<<PAI.w;
    return os;
}

ostream& operator<<(ostream& os, const vector<pa>& VEC){
	for(auto v:VEC)os<<v<<" ";
    return os;
}


int beki(int wa,int rr,int warukazu){
	if(rr==0) return 1%warukazu;
	if(rr==1) return wa%warukazu;
	wa%=warukazu;
	if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;
	ll zx=beki(wa,rr/2,warukazu);
	return (zx*zx)%warukazu;
}

              
int pr[2100000];
int inv[2100000];



int comb(int nn,int rr){
	if(rr<0 || rr>nn || nn<0) return 0;
	int r=pr[nn]*inv[rr];
	r%=mod;
	r*=inv[nn-rr];
	r%=mod;
	return r;
}

void gya(int ert){
	pr[0]=1;
	for(int i=1;i<=ert;i++){
		pr[i]=((ll)pr[i-1]*i)%mod;
	}
		inv[ert]=beki(pr[ert],mod-2,mod);
	for(int i=ert-1;i>=0;i--){
		inv[i]=(ll)inv[i+1]*(i+1)%mod;
	}
}


                


                
              //   cin.tie(0);
    		//	ios::sync_with_stdio(false);
    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            
                 //sort(ve.begin(),ve.end(),greater<int>());
//    mt19937(clock_per_sec);
  //  mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
int dp[450][100020]={};
vector<int>G[100020];
int dep[100020];

vector<int>lev[100020];

void dfs(int r,int d=0){
	dep[r]=d;
	lev[d].pb(r);
	for(auto v:G[r])dfs(v,d+1);
}

int ans[100020]={};


bool hikaku(int a,int b){
	return G[a].size()<G[b].size();
}

void solve(){


	int n,m;
	cin>>n>>m;
	for(int i=1;i<n;i++){
		int y;
		cin>>y;
		y--;
		G[y].pb(i);
	}
	dfs(0);
	
	int D;
	map<int,int>ma;
	for(int i=0;;i++){
		if(lev[i].size()==0){
			D=i;
			break;
		}
		
		ma[lev[i].size()]++;
	}
	vector<pa>ve;
	for(auto i:ma)ve.pb(i);
	int w=ve.size();
	for(int i=0;i<450;i++)for(int j=0;j<=100000;j++)dp[i][j]=-1;
	
	dp[0][0]=0;
	
	for(int i=1;i<=w;i++){
		pa v=ve[i-1];
		for(int d=0;d<v.first;d++){
			queue<int>qu;
			
			for(int j=d;j<=n;j+=v.first){
				if(dp[i-1][j]>=0)qu.push(j);
				if(qu.size()>0&&qu.front()<j-v.first*v.second)qu.pop();
				
				if(qu.size()){
					dp[i][j]=(j-qu.front())/v.first;
				}
			}
		}
	}

	if(dp[w][m]>=0){
		cout<<D<<endl;
		
		int it=w,e=m;
		while(it){
			int Q;
			Q=dp[it][e];
			assert(Q>=0);
			e-=ve[it-1].first*Q;
			ve[it-1].second=Q;
			it--;
			
		}
		for(auto v:ve)ma[v.first]=v.second;
		for(int i=0;i<D;i++){
			int g=1;
			if(ma[lev[i].size()]){
				ma[lev[i].size()]--;
				g=2;
			}
			for(auto v:lev[i]){
				ans[v]=g;
			}
		}
		
		for(int i=0;i<n;i++){
			if(ans[i]==2)cout<<"a";
			else cout<<"b";
		}
		return;
	}
	
	cout<<D+1<<endl;
	
	
	for(int i=0;i<D;i++){
		int A=0,B=0;
		sort(lev[i].begin(),lev[i].end(),hikaku);
		
		for(auto v:lev[i]){
			if(G[v].size())B++;
			else A++;
		}
		if(m>(int)lev[i].size()){
			for(auto v:lev[i])ans[v]=2;
			m-=lev[i].size();
			continue;
		}
		if(m==(int)lev[i].size()){
			for(auto v:lev[i])ans[v]=2;
			break;
		}
		if(m<=A){
			for(int j=0;j<m;j++)ans[lev[i][j]]=2;
			for(int j=m;j<A+B;j++)ans[lev[i][j]]=1;
			break;
		}
		if(m>=B){
			for(int j=0;j<A+B-m;j++)ans[lev[i][j]]=1;
			for(int j=A+B-m;j<A+B;j++)ans[lev[i][j]]=2;			
			break;
		}
		continue;
		
	}
	
	for(int i=0;i<n;i++){
		if(ans[i]==2)cout<<"a";
		else cout<<"b";
	}
	cout<<endl;
}


signed main(){
	mod=inf;
	cin.tie(0);
	ios::sync_with_stdio(false);

int n=1;
//	cin>>n;
for(int i=0;i<n;i++)solve();
	return 0;

	
}