/*計算1~n的最小公倍數*/

#include <stdio.h>
#include <stdlib.h>

/*計算x的y次方*/
int power(int x, int y){
    int i=1;
    for(;y>0;y--)
    i*=x;
    return(i);
}

/*計算A的元素個數*/
int SizeOfA(int *A)
{
    return sizeof(*A)/sizeof(*(A+0));
}

/*
main function首先從1開始尋找所有質數找出來存進P矩陣裡面
再把所有的質數對應的最高次方數存進Q矩陣裡面 
最後將PQ對應元素用power這個函數將最小公倍數算出 
*/

int main(){
    int now,n,PP[1],*P=PP,QQ[1],*Q=QQ,i,j,result;
    /*
    now:現在正在找到哪個數
    n:要從1找到哪個n的最小公倍數
    P:質數矩陣
    Q:次方矩陣
    PP跟QQ:因為不知道指標陣列如何設定初始值所以如此 
    i:for迴圈裡跑P的元素個數
    j:從SizeOfA找到的元素個數 
    result:最小公倍數 
    */
    while(scanf("%d",&n)!=EOF)
    {
                              result = 1;
                              /*已知最小質數為2，最小次方為1，也就是不考慮n<2*/ 
                              *(P+0)=2;
                              *(Q+0)=1;
                              /*從3開始跑到n*/
                              for (now=3;now<=n;now++)
                              {
                                  int k,nowtemp,l=0;
                                  j=SizeOfA(P);
                                  /*找質數以及次方數*/
                                  for (i=0;i<=j-1;i++)
                                  {
                                      /*先用k紀錄次方數，如果比之前的次方數都還大再用Q記錄下來*/
                                      k=0;
                                      nowtemp=now;
                                      while (nowtemp%P[i]==0)
                                      {
                                            k++;
                                            nowtemp/=P[i];
                                      }
                                      l+=k;
                                      if (Q[i]<k)
                                      Q[i]=k;
                                  }
                                  /*如果之前都沒有記錄到任何次方，則判定此數為質數，增加我的PQ陣列*/
                                  if (l==0)
                                  {
                                     /*紀錄P的元素個數，並且觀察到realloc函數並沒有幫我增加元素個數*/
                                     printf("%d,%d\n",SizeOfA(P),j);
                                     P = (int *) realloc(P, (j+1)*sizeof(int));
                                     Q = (int *) realloc(Q, (j+1)*sizeof(int));
                                     /*紀錄P的元素個數，並且觀察到realloc函數並沒有幫我增加元素個數*/
                                     printf("%d,%d\n",SizeOfA(P),j);
                                     /*於是這一行fail,無法執行*/
                                     P[j]=now;
                                     printf("shit!");
                                     Q[j]=1;
                                  }
                              }
                              /*最後再把所有質數跟次方乘起來*/
                              j=SizeOfA(P);
                              for (i=0;i<=j-1;i++)
                              {
                              result *= power(P[i],Q[i]);
                              printf("%d,%d,%d,%d\n",i,P[i],Q[i],result);
                              }
                              printf("%d\n",result);
                              free(P);
                              free(Q);
    }
    return 0;
}