#include<stdio.h>                                    // Pour printf
#include<stdlib.h>                                   // Pour malloc
typedef long long elem;

typedef struct maillon maillon, *liste;              //  maillon = struct maillon    liste= maillon* 
        struct maillon { elem val; liste suiv; };    // Un maillon contient un entier et un pointeur sur le maillon suivant.

typedef struct{ liste tete,queue; } lliste;          //  tete et queue pointent sur le premier et le dernier maillon d'une même liste.

void aff(liste l)                                    // Pour afficher une liste chaînée,
{ for(;l;l=l->suiv) printf("%lld ",l->val);          //   pour chacun de ses maillons on affiche la valeur qu'il contient.
  printf("\n");                                      //  On passe à la ligne une seule fois à la fois de la liste.
}

elem somme(liste l)                                  // somme des éléments de la liste l
{ elem s=0;
  for(;l;l=l->suiv) s+=l->val;
  return s;
}

liste inseretete(liste l,elem x)                     // Pour insérer l'entier x en tête d'une liste l,
{ liste a=malloc(sizeof(*a));                        //  on crée un nouveau maillon
  *a=(maillon){x,l};                                 //   dans lequel on met x et l
  return a;                                          // La nouvelle liste est représentée par le pointeur sur ce nouveau maillon
}

liste inserequeue(liste l,elem x)                    // On veut insérer l'entier x à la fin de la liste l.
{ liste p=l,q=inseretete(0,x);                       //  q est une nouvelle liste de longueur 1 formé d'un nouveau maillon contenant x
  if(!p) return q;                                   // Si l était vide, on rend cette nouvelle liste.
  while(p->suiv) p=p->suiv;                          // p avance jusqu'au dernier maillon.
  p->suiv=q;                                         // On met le nouveau maillon derrière le dernier.
  return l;                                          // La liste est toujours représentée par le pointeur sur le même premier maillon.
}

void inseretete2(lliste *a,elem x)                    // On veut insérer l'entier x en tête de liste.
{ if(a->tete)          a->tete=inseretete(a->tete,x);// Si la liste n'était pas vide, son dernier maillon reste le même.
  else        a->queue=a->tete=inseretete(a->tete,x);// Si elle était vide le nouveau maillon est à la fois le premier et le dernier.
}

void inserequeue2(lliste *a,elem x)                   // On veut insérer l'entier x en queue de liste.
{ if(a->tete) a->queue=a->queue->suiv=inseretete(0,x);// Si la liste n'était pas vide, son prenier maillon reste le même.
  else        a->queue=a->tete       =inseretete(0,x);// Si elle était vide le nouveau maillon est à la fois le premier et le dernier.
}

#if 1
typedef struct{int nmax, d, f; elem *t;} file;
#define nmax a->nmax
#define d    a->d
#define f    a->f
#define t    a->t
void file_init(file *a,int nm) { *a=(file){nm,0,0,malloc(nm*sizeof(elem))}; }
int  file_vide(file *a) { return d==f; }
void file_libere(file *a) { free(t); *a=(file){0,0,0,0}; }
elem defile(file *a) { elem x=t[d++]; if(d==nmax) d=0; return x; }
void enfile(file *a,elem x)
{ t[f++]=x;
  if(f==nmax) f=0;
  if(f==d)
  { file b;
    file_init(&b,2*nmax);
    do enfile(&b,defile(a)); while(!file_vide(a));
    file_libere(a);
    *a=b;
  }
}
#undef nmax
#undef d
#undef f
#undef t
#else
typedef lliste file;
void file_init(file *a,int nm) { a->tete=0; }
int  file_vide(file *a) { return !a->tete; }
void enfile(file *a,elem x) { inserequeue2(a,x); }
elem defile(file *a) { liste p=a->tete; elem x=p->val; a->tete=p->suiv; free(p); return x; }
void file_libere(file *a) { while(a->tete) defile(a); }
#endif

int main()
{ file a;
  int i;
  elem x,y;
  file_init(&a,1);
  for(i=1;i<=1000000;i++) enfile(&a,i);
  for(;;)
  { x=defile(&a);
    if(file_vide(&a)) break;
    y=defile(&a);
    enfile(&a,x+y);
  }
  printf("%lld\n",x);
  return 0;
}