#include <cstdio>
#include <queue>
#include <vector>
#include <ctime>

struct timer{
  clock_t start;
  timer(){
    start=clock();
  }
  ~timer(){
    printf("time:%6dms ", clock()-start);
  }
};

typedef unsigned long long u64;
#define u64fmt "%llu"

u64 p10[]={
  1ULL,
  10ULL,
  100ULL,
  1000ULL,
  10000ULL,
  
  100000ULL,
  1000000ULL,
  10000000ULL,
  100000000ULL,
  1000000000ULL,
  
  10000000000ULL,
  100000000000ULL,
  1000000000000ULL,
  10000000000000ULL,
  100000000000000ULL,
  
  1000000000000000ULL,
  100000000000000000ULL,
  1000000000000000000ULL,
  10000000000000000000ULL
};

struct s{
  u64 k;
};

bool allodd(u64 n){
  if(n==0)
    return false;
  while(n){
    if(!((n%10)&1)){
      return false;
    }
    n/=10;
  }
  return true;
}

bool allodd5[100000],preodd5[100000];
bool fastallodd(u64 n){
  if(n==0)
    return false;
  while(n){
    if(n<100000){
      return preodd5[n];
    }else{
      if(!allodd5[n%100000]){
        return false;
      }
    }
    n/=100000;
  }
  return true;
}

void prepare(){
  for(int i=0;i<100000;i++){
    allodd5[i]=allodd(100000+i);
    preodd5[i]=allodd(i);
  }
}

u64 brute(u64 m){
  for(u64 k=1;;k+=2){
    u64 n=k*m;
    if(fastallodd(n)){
      return k;
    }
  }
}

u64 fart(u64 m){
  s cur;
  cur.k=0;
  s nxt;
  s min;
  
  std::queue<s> q;
  q.push(cur);
  
  std::vector<s> *qcur, *qnxt;
  
  qcur=new std::vector<s>();
  qnxt=new std::vector<s>();
  qcur->push_back(cur);
  
  for(int d=0;;d++){
    if(qcur->empty()){
      break;
    }
    //for(size_t j=0;j<qcur->size();j++){
    //  printf(u64fmt"->"u64fmt" ",(*qcur)[j].k,((*qcur)[j].k*m)%p10[d]);
    //}
    //printf("\n");
    for(u64 i=(d==0?1:0);i<10;i++){
      for(size_t j=0;j<qcur->size();j++){
        cur=(*qcur)[j];
        nxt.k=cur.k+p10[d]*i;
        u64 nxtn=nxt.k*m;
        // printf("try "u64fmt" * "u64fmt" = "u64fmt"\n",m,nxt.k,nxt.n);
        if(fastallodd(nxtn)){
          min=nxt;
          goto superbreak;
        }
        if(fastallodd(p10[d+1]+(nxtn%p10[d+1]))){
          qnxt->push_back(nxt);
        }
      }
    }
    delete qcur;
    qcur=qnxt;
    qnxt=new std::vector<s>();
  }
  
  delete qcur;
  delete qnxt;
  printf("shit not found????\n");
  return 0;
  
  superbreak:;
  delete qcur;
  delete qnxt;
  return min.k;
}

int main(){
  prepare();
  
  u64 maxk=0;
  u64 maxn=0;
  for(u64 i=0;i<10001;i++){
    u64 m=i*2+1;
    u64 k=fart(m);
    //if(maxk<k){
    //  maxk=k;
    //  printf(u64fmt" * "u64fmt" = "u64fmt"\n",m,k,k*m);
    //}
    //if(maxn<k*m){
    //  maxn=k*m;
    //  printf(u64fmt" * "u64fmt" = "u64fmt"\n",m,k,k*m);
    //}
    printf(u64fmt" "u64fmt"\n",i+1,k); // 1-based 2n-1, 0-based 2n+1
  }
  
  #if 0 // interactive, comparing brute force and fast algorithm
  while(true){
    u64 m;
    //9999900001 breaks u64
    printf("gimme an odd number:");
    scanf(u64fmt,&m);
    if(!(m&1)){
      printf("need odd m\n");
      continue;
    }
    
    u64 k;
    {
      timer _;
      k=fart(m);
    }
    printf("fart:  "u64fmt" * "u64fmt" = "u64fmt"\n",m,k,k*m);
    {
      timer _;
      k=brute(m);
    }
    printf("brute: "u64fmt" * "u64fmt" = "u64fmt"\n",m,k,k*m);
  }
  # endif
  return 0;
}