// Original C++ solution (slower):
#include<cstdlib>

#include<cstdio>

#include<iostream>

#include<vector>

using namespace std;

#define REP(i,b,n) for(int i=b;i<n;i++)

#define rep(i,n)   REP(i,0,n)

#define ALL(C)     (C).begin(),(C).end()

#define pb         push_back



class Tree{

public:

  int value;

  vector<Tree*> child;

  Tree *parent;

  bool iscand;

  Tree(){};

  Tree(int tv,Tree *tp){

    child.clear();

    parent=tp;

    value=tv;

    iscand=false;

    child.pb(tp);

  }

  bool isvalid(int i){

    if (child[i] == NULL || child[i] == parent)return false;

    return true;

  }

  void del(Tree *now){

    rep(i,child.size()){

      if (now == child[i]){

	child.erase(child.begin()+i);

	i--;

      }

    }

  }

  int count_valid(){

    int cnt=0;

    rep(i,child.size()){

      if (isvalid(i))cnt++;

    }

    return cnt;

  }

};



int compute(int n){

  n = 3*n+1;

  while(n%2 == 0)n/=2;

  if (n > 12345678)n-=12345678;

  return n;

}



void update(Tree *now){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    update(now->child[i]);

  }

  int tmp=now->value;

  now->value=compute(now->value);

  if (now->count_valid() ==0 && tmp < now->value)now->iscand=true;

  else now->iscand=false;

}





void get_all_death(Tree *now,vector<Tree*> &wildel){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    get_all_death(now->child[i],wildel);

  }

  wildel.pb(now);

}



bool death(Tree *now,vector<Tree*> &wildel){

  if (now->value == 1){

    int cnt = 0;//count child

    Tree *ins=NULL;

    rep(i,now->child.size()){

      if (now->isvalid(i)){

	cnt++;

	ins=now->child[i];

      }

    }

    if (cnt == 1 && now->parent != NULL){

      now->parent->child.pb(ins);//because of chain

      ins->parent=now->parent;

      ins->del(now);

      ins->child.pb(now->parent);



      wildel.pb(now);

    }else get_all_death(now,wildel);

    return true;

  }



  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    if (death(now->child[i],wildel)){

      now->child.erase(now->child.begin()+i);

      i--;

    }

  }

  return false;//survive

}



void make_child(Tree *now){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    make_child(now->child[i]);

  }

  

  if (now->iscand){

    int newvalue = (now->value+1)/2;

    if (newvalue%2 == 0)newvalue++;

    Tree *newnode;

    newnode = new Tree(newvalue,now);

    now->child.pb(newnode);

  }

}



void find_new_leader(Tree *now,int &maxval,int &maxcnt,Tree* &who){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    find_new_leader(now->child[i],maxval,maxcnt,who);

  }

  

  if (now->value > maxval){

    maxval=now->value;

    maxcnt=1;

    who=now;

  }else if (now->value == maxval)maxcnt++;

}



void replace(Tree *now,Tree *parent){

  if (now == NULL)return;

  replace(now->parent,now);

  now->parent=parent;

}



Tree* find_leader(Tree *root){

  int maxval=0,maxcnt=0;

  Tree *who=NULL;

  find_new_leader(root,maxval,maxcnt,who);

  if (maxcnt == 1){

    replace(who,NULL);

    int newvalue = (who->value+1)/2;

    if (newvalue %2 == 0)newvalue--;



    Tree *bonus;

    bonus=new Tree(newvalue,who);

    who->child.pb(bonus);

    return who;

  }else return root;

}



void del_travarse(Tree *now,vector<Tree*> &wildel){

  rep(i,now->child.size()){

   if (!now->isvalid(i))continue;

   del_travarse(now->child[i],wildel);

  }



  rep(i,wildel.size()){

    now->del(wildel[i]);

  }

}



bool operation_death(Tree *root){

  bool ret=false;

  vector<Tree*> wildel;

  if (death(root,wildel))ret=true;

  del_travarse(root,wildel);

  rep(i,wildel.size())free(wildel[i]);

  return ret;

}



void count_node(Tree *now,int &cnt){

  cnt++;

  rep(i,now->child.size()){

   if (!now->isvalid(i))continue;

   count_node(now->child[i],cnt);

  }

}



void solve(int val){

  Tree *root;

  root=new Tree(val,NULL);

  int cnt=1;

  int maxnum=1;

  while(true){

    update(root);

    if (operation_death(root))break;

    make_child(root);

    root = find_leader(root);

    int tmp = 0;

    count_node(root,tmp);

    maxnum=max(maxnum,tmp);

    cnt++;

  }

  

  cout << cnt <<" " << maxnum << endl;

  return;

}



main(){

  int n;

  while(cin>>n && n){

    solve(n);

  }

}

// Optimized solution to the same problem (faster):
#include<cstdlib>

#include<cstdio>

#include<iostream>

#include<vector>

using namespace std;

#define REP(i,b,n) for(int i=b;i<n;i++)

#define rep(i,n)   REP(i,0,n)

#define ALL(C)     (C).begin(),(C).end()

#define pb         push_back



class Tree{

public:

  int value;

  vector<Tree*> child;

  Tree *parent;

  bool iscand;

  Tree(){};

  Tree(int tv,Tree *tp){

    child.clear();

    parent=tp;

    value=tv;

    iscand=false;

    child.pb(tp);

  }

  bool isvalid(int i){

    if (child[i] == NULL || child[i] == parent)return false;

    return true;

  }

  void del(Tree *now){

    rep(i,child.size()){

      if (now == child[i]){

	child.erase(child.begin()+i);

	i--;

      }

    }

  }

  int count_valid(){

    int cnt=0;

    rep(i,child.size()){

      if (isvalid(i))cnt++;

    }

    return cnt;

  }

};



int compute(int n){

  n = 3*n+1;

  while(n%2 == 0)n/=2;

  if (n > 12345678)n-=12345678;

  return n;

}



void update(Tree *now){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    update(now->child[i]);

  }

  int tmp=now->value;

  now->value=compute(now->value);

  if (now->count_valid() ==0 && tmp < now->value)now->iscand=true;

  else now->iscand=false;

}





void get_all_death(Tree *now,vector<Tree*> &wildel){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    get_all_death(now->child[i],wildel);

  }

  wildel.pb(now);

}



bool death(Tree *now,vector<Tree*> &wildel){

  if (now->value == 1){

    int cnt = 0;//count child

    Tree *ins=NULL;

    rep(i,now->child.size()){

      if (now->isvalid(i)){

	cnt++;

	ins=now->child[i];

      }

    }

    if (cnt == 1 && now->parent != NULL){

      now->parent->child.pb(ins);//because of chain

      ins->parent=now->parent;

      ins->del(now);

      ins->child.pb(now->parent);



      wildel.pb(now);

    }else get_all_death(now,wildel);

    return true;

  }



  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    if (death(now->child[i],wildel)){

      now->child.erase(now->child.begin()+i);

      i--;

    }

  }

  return false;//survive

}



void make_child(Tree *now){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    make_child(now->child[i]);

  }

  

  if (now->iscand){

    int newvalue = (now->value+1)/2;

    if (newvalue%2 == 0)newvalue++;

    Tree *newnode;

    newnode = new Tree(newvalue,now);

    now->child.pb(newnode);

  }

}



void find_new_leader(Tree *now,int &maxval,int &maxcnt,Tree* &who){

  rep(i,now->child.size()){

    if (!now->isvalid(i))continue;

    find_new_leader(now->child[i],maxval,maxcnt,who);

  }

  

  if (now->value > maxval){

    maxval=now->value;

    maxcnt=1;

    who=now;

  }else if (now->value == maxval)maxcnt++;

}



void replace(Tree *now,Tree *parent){

  if (now == NULL)return;

  replace(now->parent,now);

  now->parent=parent;

}



Tree* find_leader(Tree *root){

  int maxval=0,maxcnt=0;

  Tree *who=NULL;

  find_new_leader(root,maxval,maxcnt,who);

  if (maxcnt == 1){

    replace(who,NULL);

    int newvalue = (who->value+1)/2;

    if (newvalue %2 == 0)newvalue--;



    Tree *bonus;

    bonus=new Tree(newvalue,who);

    who->child.pb(bonus);

    return who;

  }else return root;

}



void del_travarse(Tree *now,vector<Tree*> &wildel){

  rep(i,now->child.size()){

   if (!now->isvalid(i))continue;

   del_travarse(now->child[i],wildel);

  }



  rep(i,wildel.size()){

    now->del(wildel[i]);

  }

}



bool operation_death(Tree *root){

  bool ret=false;

  vector<Tree*> wildel;

  if (death(root,wildel))ret=true;

  //  del_travarse(root,wildel);

  //  rep(i,wildel.size())free(wildel[i]);

  return ret;

}



void count_node(Tree *now,int &cnt){

  cnt++;

  rep(i,now->child.size()){

   if (!now->isvalid(i))continue;

   count_node(now->child[i],cnt);

  }

}



void solve(int val){

  Tree *root;

  root=new Tree(val,NULL);

  int cnt=1;

  int maxnum=1;

  while(true){

    update(root);

    if (operation_death(root))break;

    make_child(root);

    root = find_leader(root);

    int tmp = 0;

    count_node(root,tmp);

    maxnum=max(maxnum,tmp);

    cnt++;

  }

  

  cout << cnt <<" " << maxnum << endl;

  return;

}



main(){

  int n;

  while(cin>>n && n){

    solve(n);

  }

}

// Fastest known solution for this problem: