#include<bits/stdc++.h>
// #define ll int64_t
using namespace std;
	#define varcnts(v1,v2,v3,v4,v5,v6,v7,v8,v9,num, ...) num
	#define varcnt(a...) varcnts(a,9,8,7,6,5,4,3,2,1,0)
	#define cats(a,b) a##b
	#define cat(a,b) cats(a,b)
	#define debo(var) <<#var<<'='<<(var)<<"; "
	#define debe <<'\n'
	#define deb1(a) debo(a)
	#define deb2(a,b...) debo(a)deb1(b)
	#define deb3(a,b...) debo(a)deb2(b)
	#define deb4(a,b...) debo(a)deb3(b)
	#define deb5(a,b...) debo(a)deb4(b)
	#define deb6(a,b...) debo(a)deb5(b)
	#define deb7(a,b...) debo(a)deb6(b)
	#define deb8(a,b...) debo(a)deb7(b)
	#define deb9(a,b...) debo(a)deb8(b)
	#define deb(a...) debc cat(deb,varcnt(a))(a)debe
	#define debl(a...) tap,cerr<<__LINE__<<"|: " cat(deb,varcnt(a))(a)debe
	#define debf(a...) tap,cerr<<__FUNCTION__<<"|: " cat(deb,varcnt(a))(a)debe
	#define debli tap,cerr<<"Running on Line "<<__LINE__<<"...\n"
	#define debg(a) tap,cerr<<"Line "<<__LINE__<<"|: "<<a<<'\n' 
	#define debtim tap,cerr<<"Time on Line "<<__LINE__<<": "<<(double)clock()/CLOCKS_PER_SEC<<'\n'
	
	#define taps(_dep_) [&](int dep_) { for(int _YYC_i = 1;_YYC_i<=dep_;++_YYC_i){cerr<<"   ";} }(_dep_)
	#define infun(a...) auto _funs_ = [&]() { cerr cat(deb,varcnt(a))(a); };\
		struct _A_{                 \
			string _fun_;unsigned* _dep_;function<void()> f;                          \
			_A_(unsigned&d,function<void()> fa,string fs):_fun_(fs),_dep_(&d) {f = fa;                    \
				taps(*_dep_);cerr<<_fun_<<'(';f();    \
				cerr<<") {\n";                      \
				++*_dep_;                         \
			}                             \
			~_A_() { --*_dep_;taps(*_dep_);cerr<<"}\n"; }           \
		}_a_(__dep,_funs_,__FUNCTION__)
	#define debc taps(__dep),cerr<<"deb"<<__LINE__<<"|: "
	#define tap taps(__dep)
	static unsigned __dep = 0;
	
	#define opt ostream&operator<<
	#define opc ostream&cout
	
	template <typename T, typename _ = void>
	struct is_container : std::false_type {};
	template <typename T, typename _ = void>
	struct is_adptor : std::false_type {};
	
	template <typename... Ts>
	struct is_container_helper {};
	
	template <typename T>
	struct is_container<
	T, std::conditional_t<false,
	is_container_helper<decltype(begin(declval<T>())),
	decltype(end(declval<T>()))>,
	void>> : std::true_type {};
	template <typename T>
	struct is_adptor<
	T, std::conditional_t<false,
	is_container_helper<decltype(declval<T>().top()),
	decltype(declval<T>().pop())>,
	void>> : std::true_type {};
	
	namespace is_pair_impl{
		template<typename T>struct is_pair:std::false_type{};
		template<typename...Args>struct is_pair<std::pair<Args...>>:std::true_type{};
	}
	
	template <typename T> struct is_pair {
		static constexpr bool const value = is_pair_impl::is_pair<std::decay_t<T>>::value;
	};
	namespace is_vector_impl{
		template<typename T>struct is_vector:std::false_type{};
		template<typename...Args>struct is_vector<std::vector<Args...>>:std::true_type{};
	}
	
	template <typename T> struct is_vector {
		static constexpr bool const value = is_vector_impl::is_vector<std::decay_t<T>>::value;
	};
	template<typename T>
	constexpr bool is_otp_ext = is_pair<T>::value || is_container<T>::value || is_adptor<T>::value;
	
	
	template <class T, typename std::enable_if_t<!is_container<T>::value&&!is_adptor<T>::value, int> = 0>
	auto arr(T const& va) {
		return va;
	}
	template <class T, typename std::enable_if_t<is_container<T>::value, int> = 0>
	auto arr(T const& va) {
		vector<decltype(arr(*va.begin()))> v;
		for(auto const& a : va) v.push_back(arr(a));
		return v;
	}
	template <class T, typename std::enable_if_t<is_adptor<T>::value, int> = 0>
	auto arr(T va) {
		vector<decltype(arr(va.top()))> v;
		while(!va.empty())v.push_back(va.top()),va.pop();
		return v;
	}
	
	template<class T,size_t sz>auto arr(T(&a)[sz]){
		vector<decltype(arr(a[0]) )> res(sz);
		for(int i=0;i<(int)sz;++i)res[i]=arr(a[i]);
		return res;
	}
	
	template<class T>auto arr(valarray<T>a){
		vector<T>res;for(int i=0;i<a.size();++i)res.push_back(a[i]);
		return res;
	}
	
	template<class T,typename std::enable_if_t<is_otp_ext<T>&&std::is_same<T,string>::value==0,int> =0>
	ostream&operator<<(ostream&cerr,T const&v){
		if constexpr(is_vector<T>::value) {
			if(v.empty())return cerr<<"{}";
		
			cerr<<"{";const bool ic=is_container<decltype(v[0])>::value;
			if(ic)cerr<<'\n',++__dep,tap;
			bool isfront=1;
			for(auto const&a:v){
				if(!isfront){
					cerr<<",";if(ic)cerr<<'\n',tap;
				}isfront=0;
				cerr<<a;
			}
			if(ic)cerr<<'\n',--__dep,tap;
			cerr<<"}";
		} else if constexpr(is_pair<T>::value) {
			cerr<<"(";const bool ic=is_container<decltype(v.first)>::value||is_container<decltype(v.second)>::value;
			if(ic)cerr<<'\n',++__dep,tap;
			cerr<<v.first<<',';
			if(ic)cerr<<'\n',tap;
			cerr<<v.second;
			if(ic)cerr<<'\n',--__dep,tap;
			cerr<<")";
		} else cerr<<arr(v);
		return cerr;
	}
	
	template<class T> vector<T> arr(T*a,int n) { return vector<T>(a+1,a+n+1); }
	template<class T> vector<T> arr(T*a,T*b) { return vector<T>(a,b); }
	template<class val>
	struct un{
		string name;
		val va;
		un(string name,val va):name(name),va(va) {};
	};
	template<class T>
	opt(opc,un<T> va){return cout<<va.name<<"="<<va.va;}
	#define mkun(T,t) template<>opt(opc,un<T> va){return cout<<va.name<<"="<<(va.va>t?"'inf'":to_string(va.va));}
	mkun(int,1e7); mkun(long long,1e18);
	#define on(val) un<decltype(val)>(#val,val)
	#define mkopt(node,a...) ostream&operator<<(ostream&cerr,node _) { return cerr<<'('<<cat(mkopt,varcnt(a))(a)<<')'; }
	#define mkopt1(a) on(_.a)
	#define mkopt2(a,b...) on(_.a)<<','<<mkopt1(b)
	#define mkopt3(a,b...) on(_.a)<<','<<mkopt2(b)
	#define mkopt4(a,b...) on(_.a)<<','<<mkopt3(b)
	#define mkopt5(a,b...) on(_.a)<<','<<mkopt4(b)
	#define mkopt6(a,b...) on(_.a)<<','<<mkopt5(b)
	#define mkopt7(a,b...) on(_.a)<<','<<mkopt6(b)
	#define mkopt8(a,b...) on(_.a)<<','<<mkopt7(b)
	#define mkopt9(a,b...) on(_.a)<<','<<mkopt8(b)
	#undef opt
	#undef opc
	struct nulstream{template<class T>nulstream&operator<<(T const&va){return*this;}}cnul;
	const char*operator""_(const char*,size_t){return"\b\b";}
	#define mkopt_(node,a...) ostream&operator<<(ostream&cerr,node _){auto[a]=_;return cerr<<"{" cat(deb,varcnt(a))(a)<<"}";}
const int maxn = 2e5+10;
const int NMSK = 184756 +1;
int m;//len of mutable
using uint=uint32_t;
using ll=long long;
const ll inf=1e18;
unordered_map<uint,int>id;
uint rid[NMSK];
int trs[NMSK][10];//[id][add val is]
int endid;

string otpstr(uint msk){
	string res;for(int i=0;i<m*2;++i)res+='0'+(msk>>i&1);return res;
}

int cal_id(uint msk){
	// infun(otpstr(msk));
	assert(__builtin_popcount(msk) == m);
	int&cur=id[msk];if(cur)return cur;
	rid[cur=id.size()]=msk;
	//0,...,2m-1
	int c1=0;bool ised=1;
	for(int i=0;i<(m<<1);++i){
		if(msk>>i&1){
			++c1;
			if(i && c1<=1+i-c1 && (~msk>>(i-1)&1))
				ised=0,trs[cur][c1-1]=cal_id(msk^(0b11 << (i-1)));
		}
	}
	if(ised)
		assert(!endid),
		endid=cur;
	return cur;
}

ll f[NMSK][10];//[id][pre add is (cur it va ++)]

ll cal_f(int id,int pa){
	// infun(id,otpstr(rid[id]),pa);
	if(id==endid)return 1;
	ll&res=f[id][pa];if(~res)return res;res=0;
	int c1=0;bool mad=0;
	for(int i=0;i<(m<<1);++i){
		if(rid[id]>>i&1)++c1;
		else if(c1<m){
			if(mad||pa+1!=c1){
				res+=cal_f(trs[id][c1],c1);
				res=min(res,inf);
			}else mad=1;
		}
	}
	return res;
}

int C[27][27];
int cuse[27],swc;
signed main() {
	for(int i=0;i<27;++i)C[i][0]=1;
	for(int i=1;i<27;++i)for(int j=1;j<27;++j)C[i][j]=C[i-1][j]+C[i-1][j-1];
	// freopen("string.in","r",stdin);
	// freopen("string.out","w",stdout);
	ios::sync_with_stdio(0),cin.tie(0);
	int k;ll n;cin>>k>>n;

	// deb(m);

	string ans;

	for(m=k;m>8;m-=2){
		char a='a'+k-m,b=a+1;
		for(int j=1;j<m;++j)ans+=a,ans+=b;
		ans+=a;
	}
	// deb(ans);
	// debli;

	int curid=cal_id(((1<<m)-1)<<m),pris=-1;
	// deb(endid,otpstr(rid[endid]));
	memset(f,-1,sizeof f);memset(f[0],0,sizeof f[0]);
	int lea=k-m;
	// deb(char('a'+lea));
	for(int rk=1;rk<=m*(m+1)/2;++rk){
		// infun(rk);
		for(int c=lea;c<26;++c){
			// infun(c,char('a'+c));
			int nsw=swc+!cuse[c];
			if(c==pris||nsw>m)continue;
			ll F=cal_f(trs[curid][cuse[c]],cuse[c]);
			// assert(F>=0);
			// __int128 cc=F*C[26-lea-nsw][m-nsw];
			// deb(n);
			// deb((long double)cc);
			if(
				ll cc;__builtin_smulll_overflow(F,C[26-lea-nsw][m-nsw],&cc)||

				n<=cc){
				ans+='a'+c;pris=c;
				curid=trs[curid][cuse[c]];
				++cuse[c];swc=nsw;
				// deb(char('a'+c));
				break;
			}else n-=cc;
		}
		// assert(0);
	}
	// deb(ans);
	if((int)ans.size() == k*(k+1)/2)cout<<ans;
	else cout<<"-1";
}