#include <iostream>

class CP { 
public: 
  static const int levels=4; // the number of levels
  int maxIter;    // maximal iteration
  int aL[levels]; // allowed per level
  int uL[levels]; // used per level
  int iL[levels]; // current iteration per level
  int changedLevel; // level changed due to increment or decrement
  int topLevel;   // the top Level
  int cpLevel;    // current checkpoint level
  int tapeLevel;  // current taping level
  int adjointLevel; // current adjoint level

  CP() {
    maxIter=0;
    for (int i=0;i<levels;i++) { 
      iL[i]=aL[i]=uL[i]=ufL[i]=0;
    }
    topLevel=0;
    cpLevel=0;
    tapeLevel=0;
    adjointLevel=0;
  }

  void init(){ 
    // determine top level
    topLevel=0;
    int steps=1;
    for(int i=0;i<levels;i++) { 
      steps*=aL[i];
      if (steps<maxIter) 
	topLevel++;
      else
	break; 
    }
    if (topLevel>=levels) { 
      std::cerr << "insufficient checkpoints" << std::endl; 
    }
    for(int i=0;i<topLevel;i++) { 
      iL[i]=1;
    }
    // determine uses: 
    steps/=aL[topLevel];
    uL[topLevel]=1+maxIter/steps;
    for(int i=topLevel-1;i>=0;i--) { 
      uL[i]=aL[i];
    }
    // determine final uses: 
    ufL[topLevel]=uL[topLevel];
    steps=maxIter%steps;
    for(int i=topLevel-1;i>=0;i--) { 
      // determine top level for the rest
      int rTopLevel=0;
      int rsteps=1;
      for(int j=0;j<=i;j++) { 
	rsteps*=aL[j];
	if (rsteps<steps) 
	  rTopLevel++;
	else
	  break; 
      }
      rsteps/=aL[rTopLevel];
      ufL[rTopLevel]=steps/rsteps;
      steps%=rsteps;
    }
    for(int i=0;i<levels;i++) { 
      std::cout << "level " << i << " aL: " << aL[i] << " uL: " << uL[i] << " ufL: "  << ufL[i] << std::endl; 
    }
  }

  void operator++() { 
    for(changedLevel=0;changedLevel<topLevel;changedLevel++) { 
      if (iL[changedLevel]==uL[changedLevel])
	iL[changedLevel]=1;
      else { 
 	il[changedLevel]++;
 	break;
      }
    }
  }
    
  void operator--() { 
    for(changedLevel=0;changedLevel<levels;changedLevel++) { 
      if (iL[changedLevel]==1) {
	iL[changedLevel]=uL[iLc];
	for (int i=changedLevel;i<levels; i++) { 
	  
	} 
      }
      else { 
 	il[changedLevel]--;
 	break;
      }
    }
  }


};
    
void cpscheme(int iter,
	      bool adjoint,
 	      CP& cp) { 
   int i; 
   if (!adjoint) { 
     // increment a level and remember which level changes:  
     int iLc;  // the level that changes: 
     for(iLc=0;iLc<levels;iLc++) { 
       if (iL[iLc]==uL[iLc])
       iL[iLc]=1;
       else { 
 	il[iLc]++;
 	break;
       }
     }
     if (iLc==cpLevel) { 
       // do checkpoint
     }
   }
   else { // do the adjoint
     // decrement a level and remember which level changes:  
     int iLc;  // the level that changes: 
     for(iLc=0;iLc<levels;iLc++) { 
       if (iL[iLc]==1)
 	iL[iLc]=ul;
       else { 
 	il[iLc]++;
 	break;
       }
     }
     if (iLc==cpLevel) { 
       // do checkpoint
     }
   } 
 }

int main(void) { 
  CP cp;
  std::cout << "maxIter: "; 
  std::cin >> cp.maxIter; 
  cp.aL[0]=3;
  cp.aL[1]=4;
  cp.aL[2]=5;
  cp.aL[3]=6;
  cp.init();
  
   for (int i=0;i<maxIter;i++) { 
     cpscheme(i, cp); 
   }
}