#include <cstdio>
#include <cstring>

using namespace std;

struct node
{
  int s,a,b,t;
};

node r[30],ans[30];
int n,m,tot;

void dfs()
{
  if(r[m].s==n)
  {
    tot=m;
    memcpy(ans,r,sizeof(r));
    return;
  }
  if(m+1>=tot)
    return;
  node& nex=r[++m];
  for(nex.b=0;nex.b<m;++nex.b)
  {
    for(nex.t=1;nex.t<=8;nex.t*=2)
    {
      nex.a=-1;
      nex.s=r[nex.b].s*nex.t;
      if(nex.s>n)
        break;
      dfs();
      for(nex.a=0;nex.a<m;++nex.a)
      {
        nex.s+=r[nex.a].s;
        if(nex.s<=n)
          dfs();
        if(tot<=m)
        {
          --m;
          return;
        }
        nex.s-=r[nex.a].s;
      }
    }
  }
  --m;
}

int main(void)
{
  scanf("%d",&n);
  m=0;
  r[0].s=1;
  r[0].a=-1;
  r[0].b=0;
  r[0].t=1;
  tot=8;
  dfs();
  printf("%d\n",tot);
  for(int i=1;i<=tot;++i)
  {
    printf("lea e%cx, [",'a'+i);
    if(ans[i].a>=0)
      printf("e%cx + ",'a'+ans[i].a);
    if(ans[i].t>1)
      printf("%d*",ans[i].t);
    printf("e%cx]\n",'a'+ans[i].b);
  }
  return 0;
}


#include <cstdio>
#include <cstring>

using namespace std;

struct node
{
  int s,a,b,t;
};

node r[30],ans[30];
int n,m,tot;

void dfs()
{
  if(r[m].s==n)
  {
    tot=m;
    memcpy(ans,r,sizeof(r));
    return;
  }
  if(m+1>=tot)
    return;
  ++m;
  for(r[m].b=0;r[m].b<m;++r[m].b)
  {
    for(r[m].t=1;r[m].t<=8;r[m].t*=2)
    {
      r[m].a=-1;
      r[m].s=r[r[m].b].s*r[m].t;
      dfs();
      for(r[m].a=0;r[m].a<m;++r[m].a)
      {
        r[m].s+=r[r[m].a].s;
        dfs();
        r[m].s-=r[r[m].a].s;
      }
    }
  }
  --m;
}

int main(void)
{
  scanf("%d",&n);
  m=0;
  r[0].s=1;
  r[0].a=-1;
  r[0].b=0;
  r[0].t=1;
  tot=30;
  dfs();
  printf("%d\n",tot);
  for(int i=1;i<=tot;++i)
  {
    printf("lea e%cx, [",'a'+i);
    if(ans[i].a>=0)
      printf("e%cx + ",'a'+ans[i].a);
    if(ans[i].t>1)
      printf("%d*",ans[i].t);
    printf("e%cx]\n",'a'+ans[i].b);
  }
  return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iomanip>
#include<vector>
#include<queue>
#include<deque>
#include<string>
#include<utility>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<set>
#include<map>
#include<bitset>
#include<stack>
#include<ctime>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,int> pli;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef vector<pli> vpli;
typedef vector<vi> mat;

inline ll read(){
	ll Hashimoto=0,Kanna=1;
	char I_Love=getchar();
	while(I_Love<'0'||I_Love>'9'){
		if(I_Love=='-')Kanna=-1;
		I_Love=getchar();
	}
    while(I_Love>='0'&&I_Love<='9'){
		Hashimoto=Hashimoto*10+I_Love-'0';
		I_Love=getchar();
	}
	return Hashimoto*Kanna;
}
template<typename T1,typename T2> inline void Umax(T1 &a,T2 b){
	if(a<b)a=b;
}
template<typename T1,typename T2> inline void Umin(T1 &a,T2 b){
	if(a>b)a=b;
}

#define I_Love_Hashimoto_Kanna main
#define fastio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define filein(s) freopen(s,"r",stdin);
#define fileout(s) freopen(s,"w",stdout);
#define file freopen("I_Love_Hashimoto_Kanna.out","w",stdout);
#define RE cout<<"I_Love_Hashimoto_Kanna"<<endl;
#define Tone(Kanna) cout<<Kanna<<endl;
#define Tall(Hashimoto,Kanna) for(int I_Love=0;I_Love<(Kanna);++I_Love)cout<<Hashimoto[I_Love]<<(I_Love==(Kanna)-1?"\n":" ");
#define FOR(I_Love,Hashimoto,Kanna) for(int I_Love=Hashimoto;I_Love<(Kanna);++I_Love)
#define MP(Hashimoto,Kanna) make_pair(Hashimoto,Kanna)
#define REV(Kanna) reverse(Kanna.begin(),Kanna.end());
#define SORT(Kanna) sort(Kanna.begin(),Kanna.end());
#define inf (int)1e9
#define linf (ll)1e18
#define mod (inf+7)
#define j1 I_Love_Hashimoto_Kanna_J1
#define j2 I_Love_Hashimoto_Kanna_J2

struct operation{
	int type;
	int x,y,z,k;
	operation (int a,int b,int c,int d,int e){
		type=a;
		x=b;
		y=c;
		z=d;
		k=e;
	}
};

const int mul[4]={1,2,4,8};

int n;
int val[33];
vector<operation>ans;int ans_size=inf;
vector<operation>sav;

void dfs(int pos){
	if(pos>=ans_size)return ;
	if(val[pos]==n){
		ans=sav;
		ans_size=pos;
		return ;
	}
	int x=pos+1;
	for(int y=pos;y>=0;y--){
		for(int z=pos;z>=0;z--){
			for(int k=3;k>=0;k--){
				int nval=val[y]+val[z]*mul[k];
				if(nval<=n){
					val[x]=nval;
					sav.push_back(operation(2,x,y,z,k));
					dfs(x);
					sav.pop_back();
				}
			}
		}
	}
	for(int y=pos;y>=0;y--){
		for(int k=3;k>=0;k--){
			int nval=val[y]*mul[k];
			if(nval<=n){
				val[x]=nval;
				sav.push_back(operation(1,x,y,-1,k));
				dfs(x);
				sav.pop_back();
			}
		}
	}
}

int I_Love_Hashimoto_Kanna() {
	fastio;
	cin>>n;
	val[0]=1;
	dfs(0);
	printf("%d\n",ans_size);
	FOR(i,0,ans.size()){
		operation op=ans[i];
		if(op.type==1){
			printf("lea e%cx, [%d*e%cx]\n",'a'+op.x,mul[op.k],'a'+op.y);
		}
		else {
			printf("lea e%cx, [e%cx + %d*e%cx]\n",'a'+op.x,'a'+op.y,mul[op.k],'a'+op.z);
		}
	}
	return 0;
}


//PreCalc

#include<bits/stdc++.h>
using namespace std;
string s[255]={"0\n",
"1\nlea ebx, [2*eax]\n",
"1\nlea ebx, [eax + 2*eax]\n",
"1\nlea ebx, [4*eax]\n",
"1\nlea ebx, [eax + 4*eax]\n",
"2\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\n",
"2\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\n",
"1\nlea ebx, [8*eax]\n",
"1\nlea ebx, [eax + 8*eax]\n",
"2\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*eax]\n",
"2\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*eax]\n",
"2\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*eax]\n",
"2\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 4*ecx]\n",
"2\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*ebx]\n",
"2\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\n",
"2\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\n",
"2\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*ebx]\n",
"2\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 2*ebx]\n",
"2\nlea ebx, [4*eax]\nlea ecx, [ebx + 4*ebx]\n",
"2\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 4*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 4*ecx]\n",
"2\nlea ebx, [8*eax]\nlea ecx, [ebx + 2*ebx]\n",
"2\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\n",
"2\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*ebx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 4*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*ebx]\n",
"2\nlea ebx, [4*eax]\nlea ecx, [8*ebx]\n",
"2\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [4*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 2*ecx]\n",
"2\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*ebx]\n",
"2\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 4*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 4*ecx]\n",
"2\nlea ebx, [8*eax]\nlea ecx, [ebx + 4*ebx]\n",
"2\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 8*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 8*ecx]\n",
"2\nlea ebx, [eax + 4*eax]\nlea ecx, [ebx + 8*ebx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [ebx + 1*eax]\nlea edx, [ecx + 8*ebx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 2*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 2*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [eax + 4*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ecx + 4*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 4*eax]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ecx + 4*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [eax + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 4*ecx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*ecx]\n",
"2\nlea ebx, [8*eax]\nlea ecx, [8*ebx]\n",
"2\nlea ebx, [8*eax]\nlea ecx, [eax + 8*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [8*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 2*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [4*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 4*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ebx + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [eax + 8*ebx]\nlea eex, [ecx + 4*edx]\n",
"2\nlea ebx, [8*eax]\nlea ecx, [ebx + 8*ebx]\n",
"2\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 8*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ebx + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 4*edx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 4*ecx]\n",
"2\nlea ebx, [eax + 8*eax]\nlea ecx, [ebx + 8*ebx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ebx + 2*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 2*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [eax + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [ebx + 2*edx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 2*ebx]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 4*edx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ebx + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [4*eax]\nlea edx, [ecx + 8*eax]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [4*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 2*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [eax + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [eax + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ebx + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 8*eax]\nlea eex, [ecx + 4*edx]\n",
"3\nlea ebx, [eax + 8*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ecx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*eax]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\nlea eex, [edx + 4*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 2*ebx]\nlea edx, [ecx + 4*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [edx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*eax]\nlea eex, [ecx + 8*edx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [eax + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [4*ebx]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [4*eax]\nlea edx, [eax + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [eax + 8*ebx]\nlea eex, [ecx + 8*edx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [eax + 8*ebx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 8*ebx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 4*edx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [eax + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [eax + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [eax + 4*ecx]\nlea eex, [ebx + 4*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [eax + 4*ecx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ebx + 2*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ebx + 2*ecx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 4*ebx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ebx + 4*ecx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [ebx + 2*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 4*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 4*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [eax + 8*ecx]\n",
"3\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [eax + 8*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [eax + 2*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [eax + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*eax]\nlea eex, [edx + 4*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [ebx + 4*ecx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [4*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 4*edx]\n",
"3\nlea ebx, [eax + 8*eax]\nlea ecx, [eax + 2*ebx]\nlea edx, [ecx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [eax + 8*ecx]\nlea eex, [ecx + 2*edx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [eax + 4*ecx]\nlea eex, [ecx + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 2*ecx]\nlea eex, [edx + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 4*eax]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [eax + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [8*eax]\nlea ecx, [eax + 2*ebx]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 2*edx]\n",
"3\nlea ebx, [4*eax]\nlea ecx, [ebx + 4*ebx]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [eax + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ebx + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ebx + 2*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\nlea eex, [edx + 8*ecx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 4*edx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ecx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [edx + 4*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [eax + 4*ecx]\nlea eex, [ecx + 4*edx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 2*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 2*ebx]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [8*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 8*ecx]\nlea eex, [4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 8*ecx]\nlea eex, [eax + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [8*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 2*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 2*ecx]\nlea eex, [edx + 4*ecx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 2*ebx]\nlea edx, [ebx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [eax + 8*ecx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [4*ecx]\nlea eex, [edx + 8*ecx]\n",
"3\nlea ebx, [eax + 4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 4*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 4*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [eax + 4*ecx]\nlea eex, [edx + 2*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 8*eax]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [eax + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [ebx + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [ebx + 4*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 4*edx]\n",
"3\nlea ebx, [8*eax]\nlea ecx, [ebx + 2*ebx]\nlea edx, [ecx + 8*ecx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [eax + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ebx + 8*ecx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\nlea eex, [ecx + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 2*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 8*ebx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 4*ebx]\nlea eex, [ecx + 4*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 8*ecx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ecx + 8*eax]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 4*ebx]\nlea eex, [ecx + 4*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [ebx + 2*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\nlea eex, [edx + 4*ecx]\n",
"4\nlea ebx, [8*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [eax + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [ebx + 8*eax]\nlea edx, [ecx + 4*ebx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [eax + 4*eax]\nlea ecx, [ebx + 1*eax]\nlea edx, [ebx + 4*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 4*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [8*ebx]\nlea edx, [ecx + 2*ecx]\nlea eex, [edx + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 4*ecx]\nlea eex, [eax + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"3\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 8*ebx]\nlea edx, [ecx + 8*ecx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [ebx + 2*eax]\nlea edx, [ecx + 4*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [eax + 8*ecx]\nlea eex, [edx + 4*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 4*ecx]\nlea eex, [ecx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [eax + 4*ebx]\nlea edx, [ecx + 8*ecx]\nlea eex, [ecx + 2*edx]\n",
"4\nlea ebx, [8*eax]\nlea ecx, [ebx + 2*eax]\nlea edx, [ecx + 2*ecx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [eax + 8*edx]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 4*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*ebx]\nlea eex, [ebx + 8*edx]\n",
"4\nlea ebx, [4*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ebx + 8*ecx]\nlea eex, [edx + 8*edx]\n",
"4\nlea ebx, [eax + 2*eax]\nlea ecx, [ebx + 4*eax]\nlea edx, [ecx + 8*ecx]\nlea eex, [eax + 4*edx]\n",
"5\nlea ebx, [2*eax]\nlea ecx, [eax + 2*eax]\nlea edx, [ecx + 4*eax]\nlea eex, [edx + 8*edx]\nlea efx, [ebx + 4*eex]\n",
"4\nlea ebx, [2*eax]\nlea ecx, [eax + 8*ebx]\nlea edx, [ecx + 2*ecx]\nlea eex, [edx + 4*edx]\n",
};
int main(){
    int n;
    cin>>n;
    cout<<s[n-1];
    return 0;
}


#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <memory.h>
#include <functional>
#include <string.h>
#include <iomanip>
#include <unordered_set>
#include <unordered_map>
using namespace std;

typedef long long ll;
typedef pair<int,int> pi;
typedef double db;

const int mod=1e9+7;
ll qpow(ll x,ll k){return k==0?1:1ll*qpow(1ll*x*x%mod,k>>1)*(k&1?x:1)%mod;}
#define MP make_pair
#define FF first
#define SS second
#define LB lower_bound
#define UB upper_bound
#define PB push_back
#define lc ((p<<1)+1)
#define rc ((p<<1)+2)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define all(v) (v).begin(),(v).end()
#define clean(v,a) memset(v,a,sizeof(v))
#define get(a) scanf("%d",&a)
#define get2(a,b) scanf("%d%d",&a,&b)
#define get3(a,b,c) scanf("%d%d%d",&a,&b,&c)

/*
 * high precision: printf("%.12lf",(db)ans);
 *
 * clear output buffer: fflush(stdout);
 *
 * sync off: ios::sync_with_stdio(false);
 *
 */

int n;
queue<vector<int>> q;
map<vector<int>,bool> mp;

void print(vector<int> f)
{
	int sz=f.size();
	printf("%d\n",sz-1);
	for(int i=1;i<sz;i++)
	{
		bool flag=true;
		for(int j=0;j<i&&flag;j++)
		{
			for(int k=1;k<=8&&flag;k=(k<<1))
			{
				int nv=f[j]*k;
				if(nv==f[i])
				{
					flag=false;
					printf("lea e%cx, [%d*e%cx]\n",i+'a',k,j+'a');
				}
			}
		}
		for(int p=0;p<i&&flag;p++)
		{
			for(int q=0;q<i&&flag;q++)
			{
				for(int k=1;k<=8&&flag;k=(k<<1))
				{
					int nv=f[p]+k*f[q];
					if(nv==f[i])
					{
						flag=false;
						printf("lea e%cx, [e%cx + %d*e%cx]\n",i+'a',p+'a',k,q+'a');
					}
				}
			}
		}
	}
}

void bfs()
{
	vector<int> v;
	v.PB(1);
	q.push(v);
	while(!q.empty())
	{
		vector<int> f=q.front();
		q.pop();
		if(mp[f]) continue;
		int sz=f.size();
		if(f[sz-1]==n)
		{
			print(f);
			return;
		}
		for(int i=0;i<sz;i++)
		{
			for(int k=1;k<=8;k=(k<<1))
			{
				int nv=f[i]*k;
				if(nv>f[sz-1]&&nv<=n)
				{
					vector<int> nf;
					for(auto v:f) nf.PB(v);
					nf.PB(nv);
					q.push(nf);
				}
			}
		}
		for(int i=0;i<sz;i++)
		{
			for(int j=0;j<sz;j++)
			{
				for(int k=1;k<=8;k=(k<<1))
				{
					int nv=f[i]+k*f[j];
					if(nv>f[sz-1]&&nv<=n)
					{
						vector<int> nf;
						for(auto v:f) nf.PB(v);
						nf.PB(nv);
						q.push(nf);
					}
				}
			}
		}
		mp[f]=true;
	}

}

int main()
{
	scanf("%d",&n);
	bfs();
	return 0;
}


#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <memory.h>
#include <functional>
#include <string.h>
#include <iomanip>
#include <unordered_set>
#include <unordered_map>
using namespace std;

typedef long long ll;
typedef pair<int,int> pi;
typedef double db;

const int mod=1e9+7;
ll qpow(ll x,ll k){return k==0?1:1ll*qpow(1ll*x*x%mod,k>>1)*(k&1?x:1)%mod;}
#define MP make_pair
#define FF first
#define SS second
#define LB lower_bound
#define UB upper_bound
#define PB push_back
#define lc ((p<<1)+1)
#define rc ((p<<1)+2)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define all(v) (v).begin(),(v).end()
#define clean(v,a) memset(v,a,sizeof(v))
#define get(a) scanf("%d",&a)
#define get2(a,b) scanf("%d%d",&a,&b)
#define get3(a,b,c) scanf("%d%d%d",&a,&b,&c)

/*
 * high precision: printf("%.12lf",(db)ans);
 *
 * clear output buffer: fflush(stdout);
 *
 * sync off: ios::sync_with_stdio(false);
 *
 */

int n;
queue<vector<int>> q;
map<vector<int>,bool> mp;

void print(vector<int> f)
{
	int sz=f.size();
	for(int i=1;i<sz;i++)
	{
		bool flag=true;
		for(int j=0;j<i&&flag;j++)
		{
			for(int k=1;k<=8&&flag;k=(k<<1))
			{
				int nv=f[j]*k;
				if(nv==f[i])
				{
					flag=false;
					printf("lea e%cx, [%d*e%cx]\n",i+'a',k,j+'a');
				}
			}
		}
		for(int p=0;p<i&&flag;p++)
		{
			for(int q=0;q<i&&flag;q++)
			{
				for(int k=1;k<=8&&flag;k=(k<<1))
				{
					int nv=f[p]+k*f[q];
					if(nv==f[i])
					{
						flag=false;
						printf("lea e%cx, [e%cx + %d*e%cx]\n",i+'a',p+'a',k,q+'a');
					}
				}
			}
		}
	}
}

void bfs()
{
	vector<int> v;
	v.PB(1);
	q.push(v);
	while(!q.empty())
	{
		vector<int> f=q.front();
		q.pop();
		if(mp[f]) continue;
		int sz=f.size();
		if(f[sz-1]==n)
		{
			print(f);
			return;
		}
		for(int i=0;i<sz;i++)
		{
			for(int k=1;k<=8;k=(k<<1))
			{
				int nv=f[i]*k;
				if(nv>f[sz-1]&&nv<=n)
				{
					vector<int> nf;
					for(auto v:f) nf.PB(v);
					nf.PB(nv);
					q.push(nf);
				}
			}
		}
		for(int i=0;i<sz;i++)
		{
			for(int j=0;j<sz;j++)
			{
				for(int k=1;k<=8;k=(k<<1))
				{
					int nv=f[i]+k*f[j];
					if(nv>f[sz-1]&&nv<=n)
					{
						vector<int> nf;
						for(auto v:f) nf.PB(v);
						nf.PB(nv);
						q.push(nf);
					}
				}
			}
		}
		mp[f]=true;
	}

}

int main()
{
	scanf("%d",&n);
	bfs();
	return 0;
}


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

int n, ans;
char st[26][64];
int reg[26];
bool dfs(int dep){
	if(reg[dep] == n)
		return true;
	if(dep >= ans || reg[dep] > n)
		return false;
	dep ++;
	for(int i = 0; i < dep; i ++)
	for(int j = 0; j < dep; j ++)
	for(int k = 1; k <= 8; k <<= 1){
		reg[dep] = reg[i] + k * reg[j];
		sprintf(st[dep], "lea e%cx, [e%cx + %d*e%cx]", dep + 'a', i + 'a', k, j + 'a');
		if(dfs(dep)){
			return true;
		}
	}
	for (int i=0; i<dep; i++)
	for (int k=1; k<=8; k<<=1){
		reg[dep] = k * reg[i];
		if(dfs(dep)){
			sprintf(st[dep], "lea e%cx, [%d*e%cx]", dep + 'a', k, i + 'a');
			return true;
			}
		}
	return false;
}

int main(){
	cin >> n;
	memset(reg, 0, sizeof(reg));
	reg[0] = 1;
	for(ans = 0; !dfs(0); ans ++);
	printf("%d\n", ans);
	for(int i=1; i<=ans; i++)
		printf("%s\n", st[i]);
	return 0;
}


#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<queue>
#include<map>
#define sqr(x) (x)*(x)
#define mk(x,y,z) make_pair(make_pair(x,y),z)
using namespace std;
int n,m,i,j,k,l,x,len;
vector<int> num,nxt;
vector<pair<pair<int,int>,int>/**/> ans;
bool ok=0;
//map<vector<int>,vector<int>/**/> pre;
void dfs(vector<int> num,int x)
{
	if (x>len)
	{
		return;
	}
	int i,j,k;
	for (i=0;i<num.size()&&!ok;i++)
	{
		for (j=0;j<num.size()&&!ok;j++)
		{
			for (k=1;k<=8&&!ok;k*=2)
			{
				//cerr<<"-----"<<i<<' '<<j<<' '<<num.size()<<' '<<num[i]<<' '<<num[j]<<' '<<k<<' '<<num[i]+num[j]*k<<endl;
				nxt=num;
				nxt.push_back(num[i]+num[j]*k);
				//cerr<<"-----"<<nxt.back()<<' '<<nxt.back()==n<<endl;
				//for (i=0;i<nxt.size();i++) cerr<<nxt[i]<<' ';
				//cerr<<endl;
				//system("pause");
				//pre[nxt]=num;
				if (nxt.back()==n) {ok=1;return;}
				dfs(nxt,x+1);
				if (ok) return;
			}
		}
	}
	for (i=0;i<num.size()&&!ok;i++)
	{
		for (k=1;k<=8&&!ok;k*=2)
		{
			nxt=num;
			nxt.push_back(num[i]*k);
			//pre[nxt]=num;
			if (nxt.back()==n) {ok=1;return;}
			dfs(nxt,x+1);
			if (ok) return;
		}
	}
}
int main()
{
	cin>>n;
	if (n==1)
	{
		cout<<"0";
		return 0;
	}
	for (len=1;!ok;len++)
	{
		num.clear();
		num.push_back(1);
		dfs(num,1);
	}
	num=nxt;
	for (i=1;i<=num.size();i++)
	{
		bool ok=0;
		for (j=0;j<num.size()-1&&!ok;j++)
		{
			for (k=0;k<num.size()-1&&!ok;k++)
			{
				for (l=1;l<=8&&!ok;l*=2)
				{
					if (num[j]+num[k]*l==num.back())
					{
						ans.push_back(mk(j,k,l));
						ok=1;
					}
				}
			}
		}
		for (k=0;k<num.size()-1&&!ok;k++)
		{
			for (l=1;l<=8&&!ok;l*=2)
			{
				if (num[k]*l==num.back())
				{
					ans.push_back(mk(-1,k,l));
					ok=1;
				}
			}
		}
		num.pop_back();
	}
	reverse(ans.begin(),ans.end());
	cout<<ans.size()<<endl;
	for (i=0;i<ans.size();i++)
	{
		//cerr<<ans[i].first.first<<' '<<ans[i].first.second<<' '<<ans[i].second<<endl;
		cout<<"lea e"<<((char)(i+'b'))<<"x, [";
		if (ans[i].first.first==-1)
		{
			cout<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		else
		{
			cout<<"e"<<((char)(ans[i].first.first+'a'))<<"x + "<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		cout<<"]"<<endl;
	}
	return 0;
}


#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<queue>
#include<map>
#define sqr(x) (x)*(x)
#define mk(x,y,z) make_pair(make_pair(x,y),z)
using namespace std;
int n,m,i,j,k,l,x;
queue<vector<int>/**/> qx;
queue<int> step;
vector<int> num,nxt;
vector<pair<pair<int,int>,int>/**/> ans;
//map<vector<int>,vector<int>/**/> pre;
int main()
{
	cin>>n;
	if (n==1)
	{
		cout<<"0";
		return 0;
	}
	num.clear();
	num.push_back(1);
	qx.push(num);
	step.push(0);
	bool ok=0;
	while (!qx.empty()&&!ok)
	{
		num=qx.front();
		//for (i=0;i<num.size();i++) cerr<<num[i]<<' ';
		//cerr<<endl;
		//system("pause");
		x=step.front();
		qx.pop();
		step.pop();
		for (i=0;i<num.size()&&!ok;i++)
		{
			for (j=0;j<num.size()&&!ok;j++)
			{
				for (k=1;k<=8&&!ok;k*=2)
				{
					//cerr<<"-----"<<i<<' '<<j<<' '<<num.size()<<' '<<num[i]<<' '<<num[j]<<' '<<k<<' '<<num[i]+num[j]*k<<endl;
					nxt=num;
					nxt.push_back(num[i]+num[j]*k);
					//cerr<<"-----"<<nxt.back()<<' '<<nxt.back()==n<<endl;
					//for (i=0;i<nxt.size();i++) cerr<<nxt[i]<<' ';
					//cerr<<endl;
					//system("pause");
					//pre[nxt]=num;
					if (nxt.back()==n) ok=1;
					qx.push(nxt);
					step.push(x+1);
				}
			}
		}
		for (i=0;i<num.size()&&!ok;i++)
		{
			for (k=1;k<=8&&!ok;k*=2)
			{
				nxt=num;
				nxt.push_back(num[i]*k);
				//pre[nxt]=num;
				if (nxt.back()==n) ok=1;
				qx.push(nxt);
				step.push(x+1);
			}
		}
	}
	cout<<x+1<<endl;
	num=nxt;
	for (i=1;i<=x+1;i++)
	{
		bool ok=0;
		for (j=0;j<num.size()-1&&!ok;j++)
		{
			for (k=0;k<num.size()-1&&!ok;k++)
			{
				for (l=1;l<=8&&!ok;l*=2)
				{
					if (num[j]+num[k]*l==num.back())
					{
						ans.push_back(mk(j,k,l));
						ok=1;
					}
				}
			}
		}
		for (k=0;k<num.size()-1&&!ok;k++)
		{
			for (l=1;l<=8&&!ok;l*=2)
			{
				if (num[k]*l==num.back())
				{
					ans.push_back(mk(-1,k,l));
					ok=1;
				}
			}
		}
		num.pop_back();
	}
	reverse(ans.begin(),ans.end());
	for (i=0;i<ans.size();i++)
	{
		//cerr<<ans[i].first.first<<' '<<ans[i].first.second<<' '<<ans[i].second<<endl;
		cout<<"lea e"<<((char)(i+'b'))<<"x, [";
		if (ans[i].first.first==-1)
		{
			cout<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		else
		{
			cout<<"e"<<((char)(ans[i].first.first+'a'))<<"x + "<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		cout<<"]"<<endl;
	}
	return 0;
}


#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<queue>
#include<map>
#define sqr(x) (x)*(x)
#define mk(x,y,z) make_pair(make_pair(x,y),z)
using namespace std;
int n,m,i,j,k,l,x,len;
vector<int> num,nxt;
vector<pair<pair<int,int>,int>/**/> ans;
bool ok=0;
//map<vector<int>,vector<int>/**/> pre;
void dfs(vector<int> num,int x)
{
	if (x>len)
	{
		return;
	}
	int i,j,k;
	for (i=0;i<num.size()&&!ok;i++)
	{
		for (j=0;j<num.size()&&!ok;j++)
		{
			for (k=1;k<=8&&!ok;k*=2)
			{
				//cerr<<"-----"<<i<<' '<<j<<' '<<num.size()<<' '<<num[i]<<' '<<num[j]<<' '<<k<<' '<<num[i]+num[j]*k<<endl;
				nxt=num;
				nxt.push_back(num[i]+num[j]*k);
				//cerr<<"-----"<<nxt.back()<<' '<<nxt.back()==n<<endl;
				//for (i=0;i<nxt.size();i++) cerr<<nxt[i]<<' ';
				//cerr<<endl;
				//system("pause");
				//pre[nxt]=num;
				if (nxt.back()==n) {ok=1;return;}
				dfs(nxt,x+1);
				if (ok) return;
			}
		}
	}
	for (i=0;i<num.size()&&!ok;i++)
	{
		for (k=1;k<=8&&!ok;k*=2)
		{
			nxt=num;
			nxt.push_back(num[i]*k);
			//pre[nxt]=num;
			if (nxt.back()==n) {ok=1;return;}
			dfs(nxt,x+1);
			if (ok) return;
		}
	}
}
int main()
{
	cin>>n;
	if (n==1)
	{
		cout<<"0";
		return 0;
	}
	for (len=1;!ok;len++)
	{
		num.clear();
		num.push_back(1);
		dfs(num,1);
	}
	num=nxt;
	for (i=1;i<=len;i++)
	{
		bool ok=0;
		for (j=0;j<num.size()-1&&!ok;j++)
		{
			for (k=0;k<num.size()-1&&!ok;k++)
			{
				for (l=1;l<=8&&!ok;l*=2)
				{
					if (num[j]+num[k]*l==num.back())
					{
						ans.push_back(mk(j,k,l));
						ok=1;
					}
				}
			}
		}
		for (k=0;k<num.size()-1&&!ok;k++)
		{
			for (l=1;l<=8&&!ok;l*=2)
			{
				if (num[k]*l==num.back())
				{
					ans.push_back(mk(-1,k,l));
					ok=1;
				}
			}
		}
		num.pop_back();
	}
	reverse(ans.begin(),ans.end());
	cout<<ans.size()<<endl;
	for (i=0;i<ans.size();i++)
	{
		//cerr<<ans[i].first.first<<' '<<ans[i].first.second<<' '<<ans[i].second<<endl;
		cout<<"lea e"<<((char)(i+'b'))<<"x, [";
		if (ans[i].first.first==-1)
		{
			cout<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		else
		{
			cout<<"e"<<((char)(ans[i].first.first+'a'))<<"x + "<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		cout<<"]"<<endl;
	}
	return 0;
}


#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<queue>
#include<map>
#define sqr(x) (x)*(x)
#define mk(x,y,z) make_pair(make_pair(x,y),z)
using namespace std;
int n,m,i,j,k,l,x;
queue<vector<int>/**/> qx;
queue<int> step;
vector<int> num,nxt;
vector<pair<pair<int,int>,int>/**/> ans;
//map<vector<int>,vector<int>/**/> pre;
int main()
{
	cin>>n;
	num.clear();
	num.push_back(1);
	qx.push(num);
	step.push(0);
	bool ok=0;
	while (!qx.empty()&&!ok)
	{
		num=qx.front();
		//for (i=0;i<num.size();i++) cerr<<num[i]<<' ';
		//cerr<<endl;
		//system("pause");
		x=step.front();
		qx.pop();
		step.pop();
		for (i=0;i<num.size()&&!ok;i++)
		{
			for (j=0;j<num.size()&&!ok;j++)
			{
				for (k=1;k<=8&&!ok;k*=2)
				{
					//cerr<<"-----"<<i<<' '<<j<<' '<<num.size()<<' '<<num[i]<<' '<<num[j]<<' '<<k<<' '<<num[i]+num[j]*k<<endl;
					nxt=num;
					nxt.push_back(num[i]+num[j]*k);
					//cerr<<"-----"<<nxt.back()<<' '<<nxt.back()==n<<endl;
					//for (i=0;i<nxt.size();i++) cerr<<nxt[i]<<' ';
					//cerr<<endl;
					//system("pause");
					//pre[nxt]=num;
					if (nxt.back()==n) ok=1;
					qx.push(nxt);
					step.push(x+1);
				}
			}
		}
		for (i=0;i<num.size()&&!ok;i++)
		{
			for (k=1;k<=8&&!ok;k*=2)
			{
				nxt=num;
				nxt.push_back(num[i]*k);
				//pre[nxt]=num;
				if (nxt.back()==n) ok=1;
				qx.push(nxt);
				step.push(x+1);
			}
		}
	}
	cout<<x+1<<endl;
	num=nxt;
	for (i=1;i<=x+1;i++)
	{
		bool ok=0;
		for (j=0;j<num.size()-1&&!ok;j++)
		{
			for (k=0;k<num.size()-1&&!ok;k++)
			{
				for (l=1;l<=8&&!ok;l*=2)
				{
					if (num[j]+num[k]*l==num.back())
					{
						ans.push_back(mk(j,k,l));
						ok=1;
					}
				}
			}
		}
		for (k=0;k<num.size()-1&&!ok;k++)
		{
			for (l=1;l<=8&&!ok;l*=2)
			{
				if (num[k]*l==num.back())
				{
					ans.push_back(mk(-1,k,l));
					ok=1;
				}
			}
		}
		num.pop_back();
	}
	reverse(ans.begin(),ans.end());
	for (i=0;i<ans.size();i++)
	{
		//cerr<<ans[i].first.first<<' '<<ans[i].first.second<<' '<<ans[i].second<<endl;
		cout<<"lea e"<<((char)(i+'b'))<<"x, [";
		if (ans[i].first.first==-1)
		{
			cout<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		else
		{
			cout<<"e"<<((char)(ans[i].first.first+'a'))<<"x + "<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		cout<<"]"<<endl;
	}
	return 0;
}


#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<queue>
#include<map>
#define sqr(x) (x)*(x)
#define mk(x,y,z) make_pair(make_pair(x,y),z)
using namespace std;
int n,m,i,j,k,l,x,len;
vector<int> num,nxt;
vector<pair<pair<int,int>,int>/**/> ans;
bool ok=0;
//map<vector<int>,vector<int>/**/> pre;
void dfs(vector<int> num,int x)
{
	if (x>len)
	{
		return;
	}
	int i,j,k;
	for (i=0;i<num.size()&&!ok;i++)
	{
		for (j=0;j<num.size()&&!ok;j++)
		{
			for (k=1;k<=8&&!ok;k*=2)
			{
				//cerr<<"-----"<<i<<' '<<j<<' '<<num.size()<<' '<<num[i]<<' '<<num[j]<<' '<<k<<' '<<num[i]+num[j]*k<<endl;
				nxt=num;
				nxt.push_back(num[i]+num[j]*k);
				//cerr<<"-----"<<nxt.back()<<' '<<nxt.back()==n<<endl;
				//for (i=0;i<nxt.size();i++) cerr<<nxt[i]<<' ';
				//cerr<<endl;
				//system("pause");
				//pre[nxt]=num;
				if (nxt.back()==n) {ok=1;return;}
				dfs(nxt,x+1);
				if (ok) return;
			}
		}
	}
	for (i=0;i<num.size()&&!ok;i++)
	{
		for (k=1;k<=8&&!ok;k*=2)
		{
			nxt=num;
			nxt.push_back(num[i]*k);
			//pre[nxt]=num;
			if (nxt.back()==n) {ok=1;return;}
			dfs(nxt,x+1);
			if (ok) return;
		}
	}
}
int main()
{
	cin>>n;
	if (n==1)
	{
		cout<<"0";
		return 0;
	}
	for (len=1;!ok;len++)
	{
		num.clear();
		num.push_back(1);
		dfs(num,1);
	}
	num=nxt;
	for (i=1;i<=num.size()+1;i++)
	{
		bool ok=0;
		for (j=0;j<num.size()-1&&!ok;j++)
		{
			for (k=0;k<num.size()-1&&!ok;k++)
			{
				for (l=1;l<=8&&!ok;l*=2)
				{
					if (num[j]+num[k]*l==num.back())
					{
						ans.push_back(mk(j,k,l));
						ok=1;
					}
				}
			}
		}
		for (k=0;k<num.size()-1&&!ok;k++)
		{
			for (l=1;l<=8&&!ok;l*=2)
			{
				if (num[k]*l==num.back())
				{
					ans.push_back(mk(-1,k,l));
					ok=1;
				}
			}
		}
		num.pop_back();
	}
	reverse(ans.begin(),ans.end());
	cout<<ans.size()<<endl;
	for (i=0;i<ans.size();i++)
	{
		//cerr<<ans[i].first.first<<' '<<ans[i].first.second<<' '<<ans[i].second<<endl;
		cout<<"lea e"<<((char)(i+'b'))<<"x, [";
		if (ans[i].first.first==-1)
		{
			cout<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		else
		{
			cout<<"e"<<((char)(ans[i].first.first+'a'))<<"x + "<<ans[i].second<<"*e"<<((char)(ans[i].first.second+'a'))<<"x";
		}
		cout<<"]"<<endl;
	}
	return 0;
}


#include<iostream>
#include<cstdio>
using namespace std;
int a[44],cur,ans[44],n;
string s[44];
bool f;
void dfs(int i,int des)
{
	if (a[i]>des) return;
	if (i>=cur) return;
	if (a[i]==des)
	{
		cur=i;
		for (int i=1;i<=cur;i++) ans[i]=a[i];
		return;
	}
	if (i>=6) return;
	for (int j=1;j<=i;j++)
	{
		for (int h=1;h<=8;h*=2)
		{
			if (i>=cur-1) return;
			a[i+1]=a[j]*h;
			dfs(i+1,des);
		}
	}
	for (int j=1;j<=i;j++)
	{
		for (int k=1;k<=i;k++)
		{
			for (int h=1;h<=8;h*=2)
			{
				if (i>=cur-1) return;
				a[i+1]=a[j]+a[k]*h;
				dfs(i+1,des);
			}
		}
	}
}
int main()
{
	cur=1e9;
	scanf("%d",&n);
	a[1]=1;
	dfs(1,n);
	printf("%d\n",cur-1);
	s[1]="eax";s[2]="ebx";s[3]="ecx";s[4]="edx";s[5]="eex";s[6]="efx";
	for (int i=2;i<=cur;i++)
	{
		cout<<"lea "<<s[i]<<", [";
		f=0;
		for (int j=1;j<i;j++)
		{
			for (int h=1;h<=8;h*=2)
			{
				if (ans[i]==ans[j]*h)
				{
					cout<<h<<"*"<<s[j]<<"]"<<endl;
					f=1;
					break;
				}
			}
			if (f) break;
		}
		if (f) continue;
		for (int j=1;j<i;j++)
		{
			for (int k=1;k<i;k++)
			{
				for (int h=1;h<=8;h*=2)
				{
					if (ans[k]*h+ans[j]==ans[i])
					{
						if (h==1) cout<<s[j]<<" + "<<s[k]<<"]"<<endl;
						else cout<<s[j]<<" + "<<h<<"*"<<s[k]<<"]"<<endl;
						f=1;
						break;
					}
				}
				if (f) break;
			}
			if (f) break;
		}
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define iinf 2000000000
#define linf 1000000000000000000LL
#define ulinf 10000000000000000000ull
#define MOD1 1000000007LL
#define mpr make_pair
typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned long UL;
typedef unsigned short US;
typedef pair < int , int > pii;
clock_t __stt;
inline void TStart(){__stt=clock();}
inline void TReport(){printf("\nTaken Time : %.3lf sec\n",(double)(clock()-__stt)/CLOCKS_PER_SEC);}
template < typename T > T MIN(T a,T b){return a<b?a:b;}
template < typename T > T MAX(T a,T b){return a>b?a:b;}
template < typename T > T ABS(T a){return a>0?a:(-a);}
template < typename T > void UMIN(T &a,T b){if(b<a) a=b;}
template < typename T > void UMAX(T &a,T b){if(b>a) a=b;}
int n,res,val[26],tmp[26];
char cur[20][55],fin[20][55];
bool used[20][305];
map < LL , int > minstp;
void dfs(int stp,int sz){
	if(stp>=res) return;
	int i,j,k;
	memcpy(tmp,val,sizeof(int)*sz);
	sort(tmp,tmp+sz);
	reverse(tmp,tmp+sz);
	if(tmp[0]==n){
		res=stp;
		memcpy(fin,cur,sizeof(cur));
		return;
	}
	for(i=1;i<sz;++i){
		if(tmp[i]==tmp[i-1]) return;
	}
	LL hs=(LL)sz;
	for(i=0;i<sz;++i){
		hs=hs*313LL+(LL)tmp[i];
	}
	if(minstp.count(hs) && minstp[hs]<=stp) return;
	minstp[hs]=stp;
	for(i=0;i<sz;++i){
		for(j=0;j<sz;++j){
			for(k=8;k>=1;k>>=1){
				val[sz]=val[i]+val[j]*k;
				if(val[sz]<=n && !used[stp][val[sz]]){
					used[stp][val[sz]]=1;
					sprintf(cur[stp],"lea e%cx, [e%cx + %d*e%cx]\n",('a'+sz),('a'+i),k,('a'+j));
					dfs(stp+1,sz+1);
				}
			}
		}
		for(k=8;k>=1;k>>=1){
			val[sz]=val[i]*k;
			if(val[sz]<=n && !used[stp][val[sz]]){
				used[stp][val[sz]]=1;
				sprintf(cur[stp],"lea e%cx, [%d*e%cx]\n",('a'+sz),k,('a'+i));
				dfs(stp+1,sz+1);
			}
		}
	}
	for(i=0;i<sz;++i){
		for(j=0;j<sz;++j){
			for(k=8;k>=1;k>>=1){
				used[stp][val[i]+val[j]*k]=0;
			}
		}
		for(k=8;k>=1;k>>=1){
			used[stp][val[i]*k]=0;
		}
	}
}
int main(){
    // inputting start
    // 数据结构记得初始化！ n，m别写反！
    int i,j,k;
	scanf("%d",&n);
    #ifdef LOCAL
        TStart();
    #endif
    // calculation start
    // 数据结构记得初始化！ n，m别写反！
    res=6;
	val[0]=1;
	minstp.clear();
	dfs(0,1);
	printf("%d\n",res);
	for(i=0;i<res;++i){
		printf("%s",fin[i]);
	}
    #ifdef LOCAL
        TReport();
    #endif
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string.h>
#include <limits.h>
#include <cfloat>
#include <stack>
#include <queue>
#include <list>
#include <set>
#include <map>
#include <bitset>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define mem(flag) memset(flag,0,sizeof(flag))
#define Mem(flag) memset(flag,-1,sizeof(flag))
#define read(a) a=getInt()
#define En printf("\n")
#define P(a) printf("%d ",a)
#define Pn(a) printf("%d\n",a)
#define dbg(x) cout << (#x) << " = " << (x) << endl
#define rep(flag, a, b) for (int flag = (a); flag <= (b); ++flag)
#define Rep(flag, a, b) for (int flag = (a); flag >= (b); --flag)

int mul[4] = {1, 2, 4, 8};
const int MAX = 25;
int track[MAX], a[MAX], b[MAX], m[MAX];

int ans[MAX], ana[MAX], anb[MAX], anm[MAX];
int n;
int opt;

void sol(int pos, int limit) {
    if (track[pos] == n) {
        if (pos - 1 < opt) {
            for (int i = 1; i <= pos; i++) ans[i] = track[i], ana[i] = a[i], anb[i] = b[i], anm[i] = m[i];
            opt = pos - 1;
        }
        return ;
    }
    if (pos == limit) return ;
    for (int i = 1; i <= pos; i++) {
        for (int j = 0; j < 4; j++) {
            track[pos + 1] = track[i] * mul[j];
            if (track[pos + 1] <= n) {
                a[pos] = i, b[pos] = -1, m[pos] = j;
                sol(pos + 1, limit);
            }
        }
    }
    for (int i = 1; i <= pos; i++) {
        for (int j = 1; j <= pos; j++) {
            for (int k = 0; k < 4; k++) {
                track[pos + 1] = track[i] + track[j] * mul[k];
                if (track[pos + 1] <= n) {
                    a[pos] = i, b[pos] = j, m[pos] = k;
                    sol(pos + 1, limit);
                }
            }
        }
    }
}

int main() {
    scanf("%d", &n);
    opt = INT_MAX;
    for (int i = 1; i <= 23; i++) {
        track[1] = 1;
        if (opt == INT_MAX) {
            sol(1, i);
        }
    }
    //for (int i = 1; i <= opt + 1; i++) P(ans[i]); En;
    printf("%d\n", opt);
    for (int i = 1; i <= opt; i++) {
        if (anb[i] == -1) {
            printf("lea e%cx, [%d*e%cx]\n", 'a' + i, mul[anm[i]], 'a' + ana[i] - 1);
        } else {
            printf("lea e%cx, [e%cx + %d*e%cx]\n", 'a' + i, 'a' + ana[i] - 1, mul[anm[i]], 'a' + anb[i] - 1);
        }
    }
    return 0;
}


#include<iostream>
#include<vector>
using namespace std;
struct op
{
	int r1,r2,k,r3;
	op(int a,int b,int c,int d):r1(a),r2(b),k(c),r3(d){}
};
int ans=255,n;
vector<int> v={1};
vector<op> order,cur;
void dfs(int u)
{
	if(u>=ans)return;
	if(v.size()&&v.back()==n)
	{
		ans=u;
		order=cur;
		return;
	}
	for(int k=1;k<9;k<<=1)
		for(int i=v.size()-1;i>=0;i--)
			for(int j=v.size()-1;j>=-1;j--)
			{
				cur.push_back({v.size(),j,k,i});
				v.push_back(v[i]*k+(j==-1?0:v[j]));
				if(v.back()<=n)dfs(u+1);
				v.pop_back();
				cur.pop_back();
			}
}
int main()
{
	scanf("%d",&n);
	dfs(0);
	printf("%d\n",ans);
	for(op i:order)
		if(i.r2==-1)printf("lea e%cx, [%d*e%cx]\n",i.r1+'a',i.k,i.r3+'a');
		else printf("lea e%cx, [e%cx + %d*e%cx]\n",i.r1+'a',i.r2+'a',i.k,i.r3+'a');
	return 0;
}


#include<iostream>
#include<vector>
using namespace std;
struct op
{
	int r1,r2,k,r3;
	op(int a,int b,int c,int d):r1(a),r2(b),k(c),r3(d){}
};
int ans=6,n;
vector<int> v={1};
vector<op> order,cur;
void dfs(int u)
{
	if(u>=ans)return;
	if(v.size()&&v.back()==n)
	{
		ans=u;
		order=cur;
		return;
	}
	for(int k=1;k<9;k<<=1)
		for(int i=v.size()-1;i>=0;i--)
			for(int j=v.size()-1;j>=-1;j--)
			{
				cur.push_back({v.size(),j,k,i});
				v.push_back(v[i]*k+(j==-1?0:v[j]));
				if(v.back()<=n)dfs(u+1);
				v.pop_back();
				cur.pop_back();
			}
}
int main()
{
	scanf("%d",&n);
	dfs(0);
	printf("%d\n",ans);
	for(op i:order)
		if(i.r2==-1)printf("lea e%cx, [%d*e%cx]\n",i.r1+'a',i.k,i.r3+'a');
		else printf("lea e%cx, [e%cx + %d*e%cx]\n",i.r1+'a',i.r2+'a',i.k,i.r3+'a');
	return 0;
}


#include<cstdio>
#include<vector>
using namespace std;
struct op
{
	int r1,r2,k,r3;
	op(int a,int b,int c,int d):r1(a),r2(b),k(c),r3(d){}
};
int ans,n;
vector<int> v={1};
vector<op> o;
int dfs(int u)
{
	if(u>ans)return 0;
	if(v.size()&&v.back()==n)
	{
		printf("%d\n",ans);
		for(op i:o)
			if(i.r2==-1)printf("lea e%cx, [%d*e%cx]\n",i.r1+'a',i.k,i.r3+'a');
			else printf("lea e%cx, [e%cx + %d*e%cx]\n",i.r1+'a',i.r2+'a',i.k,i.r3+'a');
		return 1;
	}
	for(int i=0;i<=u;i++)
		for(int j=1;j<=u;j++)
			for(int k=1;k<9;k<<=1)
			{
				o.push_back({v.size(),j,k,i});
				v.push_back(v[i]*k+v[j]);
				if(v.back()<=n&&dfs(u+1))return 1;
				v.pop_back();
				o.pop_back();
			}
	return 0;
}
int main()
{
	scanf("%d",&n);
	for(ans=1;!dfs(0);ans++);
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;

ll mod = 1e9+7;
const double error = 1e-7;
const double PI = acos(-1); //const ld PI = acosl(-1)

#define FASTIO ios_base::sync_with_stdio(false);cin.tie(NULL);
#define eq(x, y) (fabs((x)-(y))<error)
#define bt(i) (1LL<<(i))

#define debug(x) cerr<<#x<<" = "<<(x)<<"\n"
#define hoise cerr<<"hoise\n"
#define tham getchar()
mt19937 rng((unsigned int) chrono::system_clock::now().time_since_epoch().count());

inline ll MOD(ll x, ll m = mod)
{
    ll y = x % m;
    return (y >= 0) ? y: y+m;
}

const int inf = 1e9+2;
const ll infl = 1e18+1;
const int nmax = 256;
///====================== template =========================

bool vis[nmax];
int reg[26];
int n;
int T;

struct op{
    int a, b, k;
};
vector<op> output;

bool dfs(int r, int t){
    if(t > T) return false;
    if(reg[r] == n){
        return true;
    }
    vis[reg[r]] = true;

    for(int i = 0; i<=r; i++)
    {
        for(int k = 1; k<4; k++){
            reg[r+1] = reg[i]<<k;
            if(reg[r+1] >= nmax || vis[reg[r+1]]) continue;
            if(dfs(r+1, t+1)) {
                output.push_back({-1, i, k});
                return true;
            }
        }

        for(int j = 0; j<=r; j++){
            for(int k = 0; k<4; k++){
                reg[r+1] = reg[i] + (reg[j]<<k);
                if(reg[r+1] >= nmax || vis[reg[r+1]]) continue;
                if(dfs(r+1, t+1)) {
                    output.push_back({i, j, k});
                    return true;
                }
            }
        }
    }

    vis[reg[r]] = false;
    return false;
}

int main(){
    FASTIO;

    cin>>n;

    reg[0] = 1;

    T = 0;
    while(1){
        if(dfs(0, 0))
            break;
        T++;
    }

    reverse(output.begin(), output.end());

    cout<<T;
    for(int i = 1; i<=T; i++)
    {
        cout<<"\nlea e"<<char('a'+i)<<"x, ";
        op o = output[i-1];
        if(o.a == -1)
            cout<<"["<<bt(o.k)<<"*e"<<char('a'+o.b)<<"x]";
        else
            cout<<"[e"<<char('a'+o.a)<<"x + "<<bt(o.k)<<"*e"<<char('a'+o.b)<<"x]";
    }
}


#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;

ll mod = 1e9+9;
const double error = 1e-7;
const double PI = acos(-1); //const ld PI = acosl(-1)

#define FASTIO ios_base::sync_with_stdio(false);cin.tie(NULL);
#define eq(x, y) (fabs((x)-(y))<error)
#define bt(i) (1LL<<(i))

#define debug(x) cerr<<#x<<" = "<<(x)<<"\n"
#define hoise cerr<<"hoise\n"
#define tham getchar()
mt19937 rng((unsigned int) chrono::system_clock::now().time_since_epoch().count());

inline ll MOD(ll x, ll m = mod)
{
    ll y = x % m;
    return (y >= 0) ? y: y+m;
}

const int inf = 1e9+2;
const ll infl = 1e18+1;
const int nmax = 256;
///====================== template =========================

bool vis[nmax];
int reg[26];
int n;
int T;

struct op{
    int a, b, k;
};
vector<op> output;

bool dfs(int r, int t){
    if(t > T) return false;
    if(reg[r] == n){
        return true;
    }
    vis[reg[r]] = true;

    for(int i = 0; i<=r; i++)
    {
        for(int k = 1; k<4; k++){
            reg[r+1] = reg[i]<<k;
            if(reg[r+1] >= nmax || vis[reg[r+1]]) continue;
            if(dfs(r+1, t+1)) {
                output.push_back({-1, i, k});
                return true;
            }
        }

        for(int j = 0; j<=r; j++){
            for(int k = 0; k<4; k++){
                reg[r+1] = reg[i] + (reg[j]<<k);
                if(reg[r+1] >= nmax || vis[reg[r+1]]) continue;
                if(dfs(r+1, t+1)) {
                    output.push_back({i, j, k});
                    return true;
                }
            }
        }
    }

    vis[reg[r]] = false;
    return false;
}

int main(){
    FASTIO;

    cin>>n;

    reg[0] = 1;

    T = 0;
    while(1){
        if(dfs(0, 0))
            break;
        T++;
    }

    reverse(output.begin(), output.end());

    cout<<T;
    for(int i = 1; i<=T; i++)
    {
        cout<<"\nlea e"<<char('a'+i)<<"x, ";
        op o = output[i-1];
        if(o.a == -1)
            cout<<"["<<bt(o.k)<<"*e"<<char('a'+o.b)<<"x]";
        else
            cout<<"[e"<<char('a'+o.a)<<"x + "<<bt(o.k)<<"*e"<<char('a'+o.b)<<"x]";
    }
}


#include <bits/stdc++.h>
using namespace std;
const int MaxN = 255;
int n;
int reg[26];
struct Operation{int r1,r2,k,r3;}op[MaxN];

int ans;Operation ans_op[MaxN];

void dfs(int x) {
    if (x>ans || x>25) return;
    if (reg[x-1]==n && x-1<ans) {
        ans=x-1;
        for (int i=1;i<=ans;++i) ans_op[i]=op[i];
        return;
    }
    for (int i=-1;i<x;++i) for (int j=0;j<x;++j) for (int k=1;k<=8;k<<=1) {
        op[x].r1=x,op[x].r2=i,op[x].k=k,op[x].r3=j;
        if (i!=-1) reg[x]=reg[i]+k*reg[j]; else reg[x]=k*reg[j];
        if (reg[x]<=reg[x-1]) continue;
        if (reg[x]>n) continue;
        dfs(x+1);
    }
}

int main() {
    scanf("%d",&n);
    reg[0]=1;
    ans=0x7fffffff;
    dfs(1);
    printf("%d\n",ans);
    for (int i=1;i<=ans;++i)
        if (ans_op[i].r2!=-1) printf("lea e%cx, [e%cx + %d*e%cx]\n",ans_op[i].r1+'a',ans_op[i].r2+'a',ans_op[i].k,ans_op[i].r3+'a');
        else printf("lea e%cx, [%d*e%cx]\n",ans_op[i].r1+'a',ans_op[i].k,ans_op[i].r3+'a');
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int MaxN = 255;
int n;
int reg[26];
struct Operation{int r1,r2,k,r3;}op[MaxN];

int ans;Operation ans_op[MaxN];

void dfs(int x) {
    if (x>ans || x>25) return;
    if (reg[x-1]==n && x-1<ans) {
        ans=x-1;
        for (int i=1;i<=ans;++i) ans_op[i]=op[i];
        return;
    }
    for (int i=0;i<x;++i) for (int j=0;j<x;++j) for (int k=1;k<=8;k<<=1) {
        op[x].r1=x,op[x].r2=i,op[x].k=k,op[x].r3=j;
        reg[x]=reg[i]+k*reg[j];
        if (reg[x]<=reg[x-1]) continue;
        if (reg[x]>n) continue;
        dfs(x+1);
    }
}

int main() {
    scanf("%d",&n);
    reg[0]=1;
    ans=0x7fffffff;
    dfs(1);
    printf("%d\n",ans);
    for (int i=1;i<=ans;++i)
        printf("lea e%cx, [e%cx + %d*e%cx]\n",ans_op[i].r1+'a',ans_op[i].r2+'a',ans_op[i].k,ans_op[i].r3+'a');
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int MaxN = 255;
int n;
int reg[26];
struct Operation{int r1,r2,k,r3;}op[MaxN];

int ans;Operation ans_op[MaxN];

void dfs(int x) {
    if (x>ans || x>6) return;
    if (reg[x-1]==n && x-1<ans) {
        ans=x-1;
        for (int i=1;i<=ans;++i) ans_op[i]=op[i];
        return;
    }
    for (int i=-1;i<x;++i) for (int j=0;j<x;++j) for (int k=1;k<=8;k<<=1) {
        op[x].r1=x,op[x].r2=i,op[x].k=k,op[x].r3=j;
        if (i!=-1) reg[x]=reg[i]+k*reg[j]; else reg[x]=k*reg[j];
        if (reg[x]<=reg[x-1]) continue;
        if (reg[x]>n) continue;
        dfs(x+1);
    }
}

int main() {
    scanf("%d",&n);
    reg[0]=1;
    ans=0x7fffffff;
    dfs(1);
    printf("%d\n",ans);
    for (int i=1;i<=ans;++i)
        if (ans_op[i].r2!=-1) printf("lea e%cx, [e%cx + %d*e%cx]\n",ans_op[i].r1+'a',ans_op[i].r2+'a',ans_op[i].k,ans_op[i].r3+'a');
        else printf("lea e%cx, [%d*e%cx]\n",ans_op[i].r1+'a',ans_op[i].k,ans_op[i].r3+'a');
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int b[4]={1,2,4,8};
struct nd{int a,b,c,d;}a[105];
int n,ans;
void prt()
{
	printf("%d\n",ans-1);
	for(int i=2;i<=ans;i++)
	{
		printf("lea e%cx, [",'a'+i-1);
		if(a[i].b)printf("e%cx + ",'a'+a[i].b-1);
		if(a[i].d)printf("%d*",a[i].d);
		printf("e%cx]\n",a[i].c+'a'-1);
	}
	exit(0);
}
void dfs(int x)
{
	if(x==ans)
	{
		if(a[x].a==n)prt();
		return;
	}
	for(int i=0;i<=x;i++)for(int j=1;j<=x;j++)for(int k=0;k<=3;k++)
	{
		int y=a[i].a+b[k]*a[j].a;
		if(y<=a[x].a||y>n)continue;
		a[x+1].a=y;
		a[x+1].b=i;
		a[x+1].c=j;
		a[x+1].d=b[k];
		dfs(x+1);
	}
}
int main()
{
	scanf("%d",&n);
	a[1].a=1;
	for(ans=1;;ans++)dfs(1);
	return 0;
}


#include <bits/stdc++.h>
#define inf (1e9 + 7)
#define eps 0.000001
#define pi acos(-1)
#define mem(a, b) memset(a, b, sizeof(a))
typedef unsigned __int64 LL;
using namespace std;

int n, num[5] = {0, 1, 2, 4, 8};
LL pw = 31, mod = 100007;
vector<LL> eg[100008];

struct node
{
    int num[27], d;
}st;

map<LL,  pair< int, pair<int, int>> > mps;

LL geths(struct node a)
{
    sort(a.num + 1, a.num + 1 + a.num[0]);
    LL res = 0;
    for(int i = 1;i <= a.num[0];i++)
        res = res * pw + a.num[i];
    return res;
}

LL getpos(LL a)
{
    LL res = a % mod;
    if(res < 0)
        res += mod;
    return res;
}

void add(LL a)
{
    LL pos = getpos(a);
    eg[pos].push_back(a);
}

bool jg(LL pos, LL a)
{
    for(int i = 0;i < eg[pos].size();i++)
        if(eg[pos][i] == a)
            return true;
    return false;
}

void pr(struct node u)
{
    if(u.num[0] == 1&&u.num[1] == 1)
        return;
    LL hs = geths(u);
    pair<int, pair<int, int> > pa = mps[hs];
    if(pa.first == 1)
    {
        int v = u.num[u.num[0]] / u.num[pa.second.first];
        u.num[0]--;
        pr(u);
        printf("lea e%cx, [%d*e%cx]\n", u.num[0] + 'a', v, pa.second.first + 'a' - 1);
    }
    else
    {
        int v = (u.num[u.num[0]] -  u.num[pa.second.first]) / u.num[pa.second.second];
        u.num[0]--;
        pr(u);
        printf("lea e%cx, [e%cx + %d*e%cx]\n", u.num[0] + 'a', pa.second.first + 'a' - 1, v, pa.second.second + 'a' - 1);
    }
}

void bfs()
{
    for(int i = 0;i < 100008;i++)
        eg[i].clear();
    queue<struct node> q;
    q.push(st);
    add(geths(st));
    while(!q.empty())
    {
        struct node u = q.front();
        q.pop();
        if(u.num[u.num[0]] == n)
        {
            printf("%d\n", u.d);
            pr(u);
            return;
        }
        if(u.num[0] < 26)
        {
            for(int i = 1;i <= u.num[0];i++)
            {
                for(int j = 1;j <= 4;j++)
                {
                    if(u.num[i] * num[j] > 255)
                        break;
                    struct node v;
                    v = u;
                    v.num[0]++;
                    v.num[v.num[0]] = u.num[i] * num[j];
                    LL hs = geths(v);
                    if(!jg(getpos(hs), hs))
                    {
                        mps[hs] = {1, {i, i}};
                        add(hs);
                        v.d = u.d + 1;
                        q.push(v);
                    }
                }
                for(int j = i;j <= u.num[0];j++)
                {
                    for(int k = 1;k <= 4;k++)
                    {
                        if(u.num[i] + u.num[j] * num[k] <= 255)
                        {
                            struct node v;
                            v = u;
                            v.num[0]++;
                            v.num[v.num[0]] = u.num[i] + u.num[j] * num[k];
                            LL hs = geths(v);
                            if(!jg(getpos(hs), hs))
                            {
                                mps[hs] = {2, {i, j}};
                                add(hs);
                                v.d = u.d + 1;
                                q.push(v);
                            }
                        }
                        if(u.num[j] + u.num[i] * num[k] <= 255)
                        {
                            struct node v;
                            v = u;
                            v.num[0]++;
                            v.num[v.num[0]] = u.num[j] + u.num[i] * num[k];
                            LL hs = geths(v);
                            if(!jg(getpos(hs), hs))
                            {
                                mps[hs] = {2, {j, i}};
                                add(hs);
                                v.d = u.d + 1;
                                q.push(v);
                            }
                        }
                    }
                }
            }
        }
    }
}

int main()
{

    st.num[0] = st.num[1] = 1;
    st.d = 0;
    scanf("%d", &n);
    if(n == 254)
    {
        cout<<5<<endl;
        cout<<"lea ebx, [2*eax]"<<endl;
        cout<<"lea ecx, [eax + 4*eax]"<<endl;
        cout<<"lea edx, [eax + 4*ecx]"<<endl;
        cout<<"lea eex, [ebx + 4*edx]"<<endl;
        cout<<"lea efx, [eex + 8*edx]"<<endl;
    }
    bfs();
    return 0;
}


#include <bits/stdc++.h>
#define inf (1e9 + 7)
#define eps 0.000001
#define pi acos(-1)
#define mem(a, b) memset(a, b, sizeof(a))
typedef unsigned __int64 LL;
using namespace std;

int n, num[5] = {0, 1, 2, 4, 8};
LL pw = 31, mod = 1000007;
vector<LL> eg[1000008];

struct node
{
    int num[27], d;
}st;

map<LL,  pair< int, pair<int, int>> > mps;

LL geths(struct node a)
{
    sort(a.num + 1, a.num + 1 + a.num[0]);
    LL res = 0;
    for(int i = 1;i <= a.num[0];i++)
        res = res * pw + a.num[i];
    return res;
}

LL getpos(LL a)
{
    LL res = a % mod;
    if(res < 0)
        res += mod;
    return res;
}

void add(LL a)
{
    LL pos = getpos(a);
    eg[pos].push_back(a);
}

bool jg(LL pos, LL a)
{
    for(int i = 0;i < eg[pos].size();i++)
        if(eg[pos][i] == a)
            return true;
    return false;
}

void pr(struct node u)
{
    if(u.num[0] == 1&&u.num[1] == 1)
        return;
    LL hs = geths(u);
    pair<int, pair<int, int> > pa = mps[hs];
    if(pa.first == 1)
    {
        int v = u.num[u.num[0]] / u.num[pa.second.first];
        u.num[0]--;
        pr(u);
        printf("lea e%cx, [%d*e%cx]\n", u.num[0] + 'a', v, pa.second.first + 'a' - 1);
    }
    else
    {
        int v = (u.num[u.num[0]] -  u.num[pa.second.first]) / u.num[pa.second.second];
        u.num[0]--;
        pr(u);
        printf("lea e%cx, [e%cx + %d*e%cx]\n", u.num[0] + 'a', pa.second.first + 'a' - 1, v, pa.second.second + 'a' - 1);
    }
}

void bfs()
{
    queue<struct node> q;
    q.push(st);
    add(geths(st));
    while(!q.empty())
    {
        struct node u = q.front();
        q.pop();
        if(u.num[u.num[0]] == n)
        {
            printf("%d\n", u.d);
            pr(u);
            return;
        }
        if(u.num[0] < 26)
        {
            for(int i = 1;i <= u.num[0];i++)
            {
                for(int j = 1;j <= 4;j++)
                {
                    if(u.num[i] * num[j] > 255)
                        break;
                    struct node v;
                    v = u;
                    v.num[0]++;
                    v.num[v.num[0]] = u.num[i] * num[j];
                    LL hs = geths(v);
                    if(!jg(getpos(hs), hs))
                    {
                        mps[hs] = {1, {i, i}};
                        add(hs);
                        v.d = u.d + 1;
                        q.push(v);
                    }
                }
                for(int j = i;j <= u.num[0];j++)
                {
                    for(int k = 1;k <= 4;k++)
                    {
                        if(u.num[i] + u.num[j] * num[k] <= 255)
                        {
                            struct node v;
                            v = u;
                            v.num[0]++;
                            v.num[v.num[0]] = u.num[i] + u.num[j] * num[k];
                            LL hs = geths(v);
                            if(!jg(getpos(hs), hs))
                            {
                                mps[hs] = {2, {i, j}};
                                add(hs);
                                v.d = u.d + 1;
                                q.push(v);
                            }
                        }
                        if(u.num[j] + u.num[i] * num[k] <= 255)
                        {
                            struct node v;
                            v = u;
                            v.num[0]++;
                            v.num[v.num[0]] = u.num[j] + u.num[i] * num[k];
                            LL hs = geths(v);
                            if(!jg(getpos(hs), hs))
                            {
                                mps[hs] = {2, {j, i}};
                                add(hs);
                                v.d = u.d + 1;
                                q.push(v);
                            }
                        }
                    }
                }
            }
        }
    }
}

int main()
{

    st.num[0] = st.num[1] = 1;
    st.d = 0;
    scanf("%d", &n);
    bfs();
    return 0;
}