API tools faq
paste
Guest User

Untitled

a guest
May 27th, 2018
131
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 99.79 KB | None | 0 0
raw download clone embed print report
  1. #include <conio.h>
  2. #include <math.h>
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include <windows.h>
  7. #include <stdbool.h>
  8. #include <io.h>
  9. #include <sys/types.h>
  10. #include <dirent.h>
  11. #include <stddef.h>
  12.  
  13. #define Version "yTiny version 2.0 - x86 [09 de Dezembro de 2011 17:31]\n"
  14. #define PI 3.14159265;
  15.  
  16. char vel[][4] = { {' ',' ',' '},{' ',' ',' '}, {' ',' ',' '} };
  17. int k, z;
  18. int jj, j2;
  19. int you = 0;
  20. int pc = 0;
  21.  
  22. int converte(void);
  23. int loga(void);
  24. int shell(void);
  25. int ajuda(void);
  26. int start(void);
  27. int raiz(void);
  28. int freq(void);
  29. int freq1(void);
  30. int romanos(void);
  31. int cpotencia(void);
  32. int calculadora(void);
  33. int pi(void);
  34. int area(void);
  35. int main(void);
  36. int pwd(void);
  37. int control(void);
  38. int atalhos(void);
  39. int games(void);
  40. int vinteum(void);
  41. int bissexto(void);
  42. void clrscr();
  43. int imprime(void);
  44. int lerp(void);
  45. int troca(int s, int t);
  46. int xwin(void);
  47. int owin(void);
  48. int jogapc(void);
  49. int resetar(void);
  50. int velha(void);
  51. char *replace(char *st, char *orig, char *repl);
  52.  
  53. //----------------------------------------------------------------------------------
  54.  
  55. int loga(void) /* Função para fazer Login */
  56. {
  57.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  58.     int i, inc;
  59.     char mes[4], dia[3], ano[5], login[5] = "root", sair[2], passwd[255], senha[255];
  60.     clrscr();
  61.     time_t rawtime;
  62.     struct tm * timeinfo;
  63.     time ( &rawtime );
  64.     timeinfo = localtime(&rawtime);
  65.    
  66.     FILE *arquivo = fopen("config/system/user/passwd.bin", "rb");
  67.     if(!arquivo){
  68.                  printf("Erro na abertura do arquivo de Senha.");
  69.                  getch();
  70.                  return(pwd());
  71.     }
  72.    
  73.     if(arquivo != NULL){
  74.                  fseek(arquivo, 0, SEEK_END);
  75.                  long tam_arquivo = ftell(arquivo);
  76.                  rewind(arquivo);
  77.  
  78.                  char *buffer = (char*)malloc(sizeof(char) * tam_arquivo);
  79.                  if(buffer != NULL){
  80.                            size_t resultado = fread(buffer, 1, tam_arquivo, arquivo);
  81.                            if(resultado == tam_arquivo){
  82.                                    /* Não faz nada */
  83.                            }
  84.                  }
  85.  
  86.                  fclose(arquivo);
  87.    
  88.                  printf("login as: ");
  89.                  scanf("%s", &login);
  90.                  printf("%s@ytiny's password: ", login);
  91.                  scanf("%s", &senha);
  92.        
  93.                  if(strcmp(login, "root") == 0 && strcmp(senha, buffer) == 0){
  94.                           clrscr();
  95.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  96.                           printf(" ---------   ");
  97.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  98.                           printf(" Powered by: C/C++\n");
  99.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  100.                           printf("|  ");
  101.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
  102.                           printf(" %cv%c", 167, 167);
  103.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  104.                           printf("   |   ");
  105.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  106.                           printf("Bem Vindo(a) ao yTiny 2.0\n");    
  107.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  108.                           printf("|  ");
  109.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
  110.                           printf("/(_)\\");
  111.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  112.                           printf("  |   ");
  113.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  114.                           printf(Version, "\n");
  115.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  116.                           printf("|  ");
  117.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
  118.                           printf(" ^ ^ ");
  119.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  120.                           printf("  |   ");
  121.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  122.                           printf("%s", asctime(timeinfo));
  123.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  124.                           printf(" ---------    ");
  125.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  126.                           printf("'A realidade n%co existe. Voc%c que a cria.'\n", 198, 136);
  127.                           return(shell());
  128.                  }
  129.    
  130.                  else if(login != "root" || senha != buffer){
  131.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  132.                           printf("\nlogin as incorrect.\n");
  133.                           printf("deseja sair? (s/n) ");
  134.                           scanf("%s", &sair);
  135.                           if(strcmp(sair, "s")== 0){
  136.                                    exit(0);
  137.                           }
  138.          
  139.                           else{
  140.                                    return(loga());
  141.                           }
  142.                  }
  143.     }
  144.     exit(0);
  145. }
  146.  
  147. /* Declarando Variáveis Globais */
  148.  
  149. char lst[255] = "disk", list[255], back[255];
  150.  
  151. //----------------------------------------------------------------------------------
  152.  
  153. int shell(void) /* Função para Processar comandos */
  154. {
  155.     DIR *dp;
  156.     struct dirent *ep;
  157.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  158.     char mes[4], dia[3], ano[5];
  159.     char cmd[255], cmd1[255], dir[255] = "/yTiny", vi[255], vi2[255], c;
  160.     time_t rawtime;
  161.     struct tm * timeinfo;
  162.     time ( &rawtime );
  163.     timeinfo = localtime(&rawtime);
  164.        
  165.    
  166.     printf("\nroot@ytiny:~# %s ", lst);
  167.     scanf("%s", &cmd);    
  168.    
  169.     if(strcmp(cmd,"/?")== 0 || strcmp(cmd,"help")== 0){
  170.                      return(ajuda());
  171.     }
  172.    
  173.     if(strcmp(cmd,"exit")== 0){
  174.                      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);      
  175.                      printf("saindo...");
  176.                      Sleep(1000);      
  177.                      exit(0);
  178.     }
  179.                      
  180.     if(strcmp(cmd, "pwd") == 0){
  181.                       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  182.                       puts(lst);    
  183.                       return(shell());
  184.     }
  185.    
  186.     if(cmd[0] == 'v' && cmd[1] == 'i' && cmd[2] == ':'){
  187.               SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  188.               strcpy(vi2, replace(cmd, "vi:", ""));
  189.               sprintf(vi, "%s/%s", lst, vi2);
  190.               FILE *arquivo = fopen(vi, "r");
  191.               if(!arquivo){
  192.                  printf("Arquivo invalido", 135);
  193.                  getch();
  194.                  return(shell());
  195.               }
  196.              
  197.               if(arquivo != NULL){
  198.                    while((c = getc(arquivo) ) != EOF)
  199.                             printf("%c", c);
  200.                             printf("\n");
  201.                    return(shell());
  202.               }
  203.               strcpy(vi, "");
  204.               fclose(arquivo);
  205.     }
  206.    
  207.     if(strcmp(cmd, "ls") == 0){
  208.                       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  209.                       strcat(dir, "/");
  210.                       strcat(dir, lst);
  211.                       dp = opendir(dir);
  212.                       if (dp != NULL){
  213.                          while (ep = readdir (dp))
  214.                                puts (ep->d_name);
  215.                          (void) closedir (dp);
  216.                       }
  217.                      
  218.                       else
  219.                           printf("N%co foi possivel abrir o diretorio.\n", 198);
  220.                       return(shell());
  221.     }
  222.    
  223.     if(cmd[0] == 'c' && cmd[1] == 'd' && cmd[2] == ':'){
  224.                       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  225.                       chdir(replace(cmd, "cd:", lst));    
  226.                       strcpy(list, lst);
  227.                       strcat(list, replace(cmd, "cd:", "/"));
  228.                       strcpy(back, "");
  229.                       strcat(back, replace(cmd, "cd:", "/"));
  230.                       strcpy(lst, list);
  231.                       return(shell());                      
  232.     }
  233.    
  234.     if(cmd[0] == '.' && cmd[1] == '.' && cmd[2] == '/'){
  235.                       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  236.                       strcpy(lst, "disk");
  237.                       chdir(cmd);
  238.                       return(shell());              
  239.     }
  240.    
  241.     if(cmd[0] == 'm' && cmd[1] == 'd' && cmd[2] == ':'){
  242.                       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  243.                       mkdir(replace(cmd, "md:", lst));  
  244.                       return(shell());
  245.     }
  246.    
  247.     if(cmd[0] == 'r' && cmd[1] == 'd' && cmd[2] == ':'){
  248.                       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  249.                       rmdir(replace(cmd, "rd:", lst));    
  250.                       return(shell());
  251.     }
  252.    
  253.     if(strcmp(cmd, "reboot") == 0){
  254.                      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);        
  255.                      printf("reiniciando...");      
  256.                      Sleep(1000);
  257.                      clrscr();
  258.                      Sleep(1000);  
  259.                      return(main());
  260.     }
  261.    
  262.     if(strcmp(cmd, "intro") == 0){
  263.                    clrscr();
  264.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  265.                    printf(" ---------   ");
  266.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  267.                    printf(" Powered by: C/C++\n");
  268.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  269.                    printf("|  ");
  270.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
  271.                    printf(" %cv%c", 167, 167);
  272.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  273.                    printf("   |   ");
  274.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  275.                    printf("Bem Vindo(a) ao yTiny 2.0\n");    
  276.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  277.                    printf("|  ");
  278.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
  279.                    printf("/(_)\\");
  280.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  281.                    printf("  |   ");
  282.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  283.                    printf(Version, "\n");
  284.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  285.                    printf("|  ");
  286.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
  287.                    printf(" ^ ^ ");
  288.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  289.                    printf("  |   ");
  290.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  291.                    printf("%s", asctime(timeinfo));
  292.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  293.                    printf(" ---------    ");
  294.                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  295.                    printf("'A realidade n%co existe. Voc%c que a cria.'\n", 198, 136);
  296.                    return(shell());
  297.     }
  298.    
  299.     if(strcmp(cmd, "version") == 0){
  300.                      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);          
  301.                      printf(Version, "\n");
  302.                      return(shell());
  303.     }
  304.    
  305.     if(strcmp(cmd, "clear") == 0){
  306.                      clrscr();
  307.                      return(shell());      
  308.     }
  309.    
  310.     if(strcmp(cmd, "date") == 0){
  311.                      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);      
  312.                      printf("%s", asctime (timeinfo));
  313.                      return(shell());
  314.     }
  315.    
  316.     if(strcmp(cmd, "logout") == 0){
  317.                      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);        
  318.                      printf("deslogando...");
  319.                      Sleep(1000);        
  320.                      clrscr();
  321.                      return(loga());
  322.     }
  323.                      
  324.     if(strcmp(cmd, "program") == 0){
  325.                      return(start());
  326.     }
  327.    
  328.     if(strcmp(cmd, "control") == 0){
  329.                      return(control());
  330.     }    
  331.    
  332.     if(strcmp(cmd, "raiz") == 0){
  333.                    return(raiz());
  334.     }
  335.    
  336.     if(strcmp(cmd, "freq") == 0){
  337.                    return(freq());
  338.     }
  339.    
  340.     if(strcmp(cmd, "romanos") == 0){
  341.                    return(romanos());
  342.     }
  343.    
  344.     if(strcmp(cmd, "potencia") == 0){
  345.                    return(cpotencia());
  346.     }
  347.    
  348.     if(strcmp(cmd, "calc") == 0){
  349.                    return(calculadora());
  350.     }
  351.    
  352.     if(strcmp(cmd, "pi") == 0){
  353.                    return(pi());
  354.     }
  355.    
  356.     if(strcmp(cmd, "diasanos") == 0){
  357.                    return(diasanos());
  358.     }
  359.    
  360.     if(strcmp(cmd, "freq") == 0){
  361.                    return(freq());
  362.     }
  363.    
  364.     if(strcmp(cmd, "atalhos") == 0){
  365.                    return(atalhos());
  366.     }
  367.    
  368.     if(strcmp(cmd, "games") == 0){
  369.                    return(games());
  370.     }
  371.    
  372.     if(strcmp(cmd, "21") == 0){
  373.                    return(vinteum());
  374.     }
  375.    
  376.     if(strcmp(cmd, "bix") == 0){
  377.                    return(bissexto());
  378.     }
  379.    
  380.     if(strcmp(cmd, "velha") == 0){
  381.                    return(velha());
  382.     }
  383.    
  384.     else{
  385.          SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  386.          printf("Comando n%co encontrado.\n", 198);
  387.          return(shell());
  388.     }
  389.    
  390.     getch();
  391.     return(shell());
  392. }
  393.  
  394. //----------------------------------------------------------------------------------
  395.  
  396. char *replace(char *st, char *orig, char *repl){
  397.      static char buffer[4096];
  398.      char *ch;
  399.      
  400.      if (!(ch = strstr(st, orig)))
  401.         return st;
  402.      
  403.      strncpy(buffer, st, ch-st);  
  404.      buffer[ch-st] = 0;
  405.      sprintf(buffer+(ch-st), "%s%s", repl, ch+strlen(orig));
  406.      return buffer;
  407. }
  408.  
  409. //----------------------------------------------------------------------------------
  410.  
  411. void clrscr() /* Limpar tela */
  412. {
  413.      COORD coordScreen = { 0, 0 };
  414.      DWORD cCharsWritten;
  415.      CONSOLE_SCREEN_BUFFER_INFO csbi;
  416.      DWORD dwConSize;
  417.      HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  418.  
  419.      GetConsoleScreenBufferInfo(hConsole, &csbi);
  420.      dwConSize = csbi.dwSize.X * csbi.dwSize.Y;
  421.      FillConsoleOutputCharacter(hConsole, TEXT(' '), dwConSize, coordScreen, &cCharsWritten);
  422.      GetConsoleScreenBufferInfo(hConsole, &csbi);
  423.      FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten);
  424.      SetConsoleCursorPosition(hConsole, coordScreen);
  425. }
  426.  
  427. //----------------------------------------------------------------------------------
  428.  
  429. /* Jogar jogo da velha */
  430.  
  431. int imprime(void)
  432. {
  433.     printf("\n");
  434.     printf(" Voc\x88: %d / Computador: %d \n\n", you, pc);
  435.     printf("    C1  C2  C3\n\n");
  436.     for(z=0; z<3; z++){
  437.              if(z==0) printf("L1");
  438.              if(z==1) printf("L2");
  439.              if(z==2) printf("L3");
  440.              for(k = 0; k < 3; k++){
  441.                    if(k == 0) printf("   %c ", vel[z][k]);
  442.                    else printf(" %c ", vel[z][k]);
  443.                    if(k<2) printf("|");
  444.              }
  445.     if(z < 2) printf("\n    -----------\n");
  446.     }
  447.     printf("\n\n");
  448. }
  449.  
  450. // ----------------------------------------
  451.  
  452. int troca(int s, int t)
  453. {
  454.     if(vel[s-49][t-49] == 'x' || vel[s-49][t-49] == 'o'){
  455.                        printf("\n\nEspa\x87o j\xA0 preenchido\n");
  456.                        lerp();
  457.     }
  458.  
  459.     if(vel[s-49][t-49] == ' ') vel[s-49][t-49] = 'x';
  460. }
  461.  
  462. // ----------------------------------------
  463.  
  464. int lerp(void)
  465. {
  466.     int i, j;
  467.  
  468.     printf("\nDigite as coordenadas de sua jogada: (0 para sair)\n\nL:");
  469.     i = getche();
  470.  
  471.     printf("\nC:");
  472.     j = getche();
  473.  
  474.     if(i >= 49 && i < 52 && j >= 49 && j < 52) troca(i, j);
  475.     else if(i >= 0 || i <= 0 || i == 0 && j >= 0 || j <= 0 || j == 0) return(games());
  476.    
  477.     else{
  478.          printf("\n\nERRO!\n\nCoordenada inv\xA0lida.\n\n");
  479.          lerp();
  480.     }
  481. }
  482.  
  483. // ----------------------------------------
  484.  
  485. int xwin(void)
  486. {
  487.     printf("\nVoc\x88 GANHOU!\n");
  488.     you++;
  489.     resetar();
  490. }
  491.  
  492. // ----------------------------------------
  493.  
  494. int owin(void)
  495. {
  496.     printf("\nVoc\x88 PERDEU!\n");
  497.     pc++;
  498.     resetar();
  499. }
  500.  
  501. // ----------------------------------------
  502.  
  503. int jogapc(void)
  504. {
  505.     int x = 1;
  506.  
  507.     if(vel[2][2] == 'x' && vel[0][2] == 'x')
  508.                  if(vel[1][2]==' ' && x){
  509.                                vel[1][2]='o';
  510.                                x = 0;
  511.                  }
  512.  
  513.                  if(vel[2][0] == 'x' && vel[0][2] == 'x')
  514.                               if(vel[1][0]==' ' && x){
  515.                                               vel[1][0]='o';
  516.                                               x=0;
  517.                               }
  518.  
  519.  
  520.                  if(vel[2][0] == 'o' && vel[1][1] == 'o')
  521.                                    if(vel[0][2] == ' ' && x){
  522.                                                    vel[0][2] = 'o';
  523.                                                    x = 0;
  524.                                    }
  525.                                    
  526.                  if(vel[0][2] == 'o' && vel[2][2] == 'o')
  527.                                    if(vel[2][0] == ' ' && x){
  528.                                                 vel[2][0] = 'o';
  529.                                                 x = 0;
  530.                                    }
  531.                                    
  532.                  if(vel[2][0] == 'o' && vel[0][2] == 'o')
  533.                                    if(vel[1][1] == ' ' && x){
  534.                                                 vel[1][1] = 'o';
  535.                                                 x = 0;
  536.                                    }
  537.  
  538.                  if(vel[0][0] == 'o' && vel[1][1] == 'o')
  539.                                       if(vel[2][2] == ' ' && x){
  540.                                       vel[2][2] = 'o';
  541.                                       x = 0;
  542.                                    }
  543.                  
  544.                  if(vel[1][1] == 'o' && vel[2][2] == 'o')
  545.                                    if(vel[0][0] == ' ' && x){
  546.                                                    vel[0][0] = 'o';
  547.                                                    x = 0;
  548.                                    }
  549.  
  550.                  if(vel[0][0] == 'o' && vel[2][2] == 'o')
  551.                                    if(vel[1][1] == ' ' && x){
  552.                                                     vel[1][1] = 'o';
  553.                                                     x = 0;
  554.                                    }
  555.  
  556.                  if(vel[0][0] == 'o' && vel[1][0] == 'o')
  557.                                    if(vel[2][0] == ' ' && x){
  558.                                    vel[2][0] = 'o';
  559.                                    x = 0;
  560.                  }
  561.                  
  562.                  if(vel[1][0] == 'o' && vel[2][0] == 'o')
  563.                                    if(vel[0][0]==' ' && x){
  564.                                                    vel[0][0] = 'o';
  565.                                                    x = 0;
  566.                                    }
  567.                                    
  568.                  if(vel[0][0] == 'o' && vel[2][0] == 'o')
  569.                                    if(vel[1][0] == ' ' && x){
  570.                                                 vel[1][0] = 'o';
  571.                                                 x = 0;
  572.                                    }
  573.  
  574.                  if(vel[0][1] == 'o' && vel[1][1] == 'o')
  575.                                    if(vel[2][1] == ' ' && x){
  576.                                                    vel[2][1] = 'o';
  577.                                                    x = 0;
  578.                                    }
  579.                                    
  580.                  if(vel[1][1] == 'o' && vel[2][1] == 'o')
  581.                                    if(vel[0][1] == ' ' && x){
  582.                                                    vel[0][1] = 'o';
  583.                                                    x = 0;
  584.                                    }
  585.                                    
  586.                  if(vel[0][1] == 'o' && vel[2][1] == 'o')
  587.                                    if(vel[1][1] == ' ' && x){
  588.                                                    vel[1][1] = 'o';
  589.                                                    x = 0;
  590.                                    }
  591.  
  592.                  if(vel[0][2] == 'o' && vel[1][2] == 'o')
  593.                                    if(vel[2][2] == ' ' && x){
  594.                                                    vel[2][2] = 'o';
  595.                                                    x = 0;
  596.                                    }
  597.                                    
  598.                  if(vel[1][2] == 'o' && vel[2][2] == 'o')
  599.                                    if(vel[0][2] == ' ' && x){
  600.                                                    vel[0][2] = 'o';
  601.                                                    x = 0;
  602.                                    }
  603.                                    
  604.                  if(vel[0][2] == 'o' && vel[2][2] == 'o')
  605.                                    if(vel[1][2] == ' ' && x){
  606.                                                    vel[1][2] = 'o';
  607.                                                    x = 0;
  608.                                    }
  609.  
  610.                  if(vel[0][0] == 'o' && vel[0][1] == 'o')
  611.                                    if(vel[0][2] == ' ' && x){
  612.                                                    vel[0][2] = 'o';
  613.                                                    x = 0;
  614.                                    }
  615.                                    
  616.                  if(vel[0][1] == 'o' && vel[0][2] == 'o')
  617.                                    if(vel[0][0] == ' ' && x){
  618.                                                    vel[0][0] = 'o';
  619.                                                    x = 0;
  620.                                    }
  621.                                    
  622.                  if(vel[0][0] == 'o' && vel[0][2] == 'o')
  623.                                    if(vel[0][1] == ' ' && x){
  624.                                                    vel[0][1] = 'o';
  625.                                                    x = 0;
  626.                                    }
  627.  
  628.                  if(vel[1][0] == 'o' && vel[1][1] == 'o')
  629.                                    if(vel[1][2] == ' ' && x){
  630.                                                    vel[1][2] = 'o';
  631.                                                    x = 0;
  632.                                    }
  633.                                    
  634.                  if(vel[1][1] == 'o' && vel[1][2] == 'o')
  635.                                    if(vel[1][0] == ' ' && x){
  636.                                                    vel[1][0] = 'o';
  637.                                                    x = 0;
  638.                                    }
  639.                                    
  640.                  if(vel[1][0] == 'o' && vel[1][2] == 'o')
  641.                                    if(vel[1][1] == ' ' && x){
  642.                                                    vel[1][1] = 'o';
  643.                                                    x = 0;
  644.                                    }
  645.  
  646.                  if(vel[2][0] == 'o' && vel[2][1] == 'o')
  647.                                    if(vel[2][2] == ' ' && x){
  648.                                                    vel[2][2] = 'o';
  649.                                                    x = 0;
  650.                                    }
  651.                                    
  652.                  if(vel[2][1] == 'o' && vel[2][2] == 'o')
  653.                                    if(vel[2][0] == ' ' && x){
  654.                                                    vel[2][0] = 'o';
  655.                                                    x = 0;
  656.                                    }
  657.                                    
  658.                  if(vel[2][0] == 'o' && vel[2][2] == 'o')
  659.                                    if(vel[2][1] == ' ' && x){
  660.                                                    vel[2][1] = 'o';
  661.                                                    x = 0;
  662.                                    }
  663.  
  664.                  if(jj && x){
  665.                        if(vel[0][0] == 'x'){
  666.                                     vel[1][1] = 'o';
  667.                                     x = 0;
  668.                                     jj = 0;
  669.                        }
  670.  
  671.                        if(vel[1][1] == 'x'){
  672.                                     vel[2][0] = 'o';
  673.                                     x = 0;
  674.                                     jj = 0;
  675.                        }
  676.  
  677.                        if(vel[2][2] == 'x'){
  678.                                     vel[1][1] = 'o';
  679.                                     x = 0;
  680.                                     jj = 0;
  681.                        }
  682.  
  683.                        if(vel[0][1] == 'x'){
  684.                                     vel[0][2] = 'o';
  685.                                     x = 0;
  686.                                     jj = 0;
  687.                        }
  688.  
  689.                        if(vel[0][2] == 'x'){
  690.                                     vel[1][1] = 'o';
  691.                                     x = 0;
  692.                                     jj = 0;
  693.                        }
  694.  
  695.                        if(vel[1][0] == 'x'){
  696.                                     vel[0][2] = 'o';
  697.                                     x = 0;
  698.                                     jj=0;
  699.                        }
  700.  
  701.                        if(vel[1][2] == 'x'){
  702.                                     vel[2][0] = 'o';
  703.                                     x = 0;
  704.                                     jj = 0;
  705.                        }
  706.  
  707.                        if(vel[2][0] == 'x'){
  708.                                     vel[1][1] = 'o';
  709.                                     x = 0;
  710.                                     jj = 0;
  711.                        }
  712.  
  713.                        if(vel[2][1] == 'x'){
  714.                                     vel[0][0] = 'o';
  715.                                     x = 0;
  716.                                     jj = 0;
  717.                        }
  718.                  }
  719.  
  720.                  if(vel[2][0] == 'x' && vel[1][1] == 'x')
  721.                                    if(vel[0][2] == ' ' && x){
  722.                                                    vel[0][2] = 'o';
  723.                                                    x = 0;
  724.                                    }
  725.                                    
  726.                  if(vel[0][2] == 'x' && vel[2][2] == 'x')
  727.                                    if(vel[2][0] == ' ' && x){
  728.                                                    vel[2][0] = 'o';
  729.                                                     x = 0;
  730.                                    }
  731.                  
  732.                  if(vel[2][0] == 'x' && vel[0][2] == 'x')
  733.                                    if(vel[1][1] == ' ' && x){
  734.                                                    vel[1][1] = 'o';
  735.                                                    x = 0;
  736.                                    }
  737.  
  738.      
  739.  
  740.                  if(vel[0][0] == 'x' && vel[1][1] == 'x')
  741.                                    if(vel[2][2] == ' ' && x){
  742.                                                    vel[2][2] = 'o';
  743.                                                    x = 0;
  744.                                    }
  745.                  
  746.                  if(vel[1][1] == 'x' && vel[2][2] == 'x')
  747.                                    if(vel[0][0] == ' ' && x){
  748.                                                    vel[0][0] = 'o';
  749.                                                    x = 0;
  750.                                    }
  751.                  
  752.                  if(vel[0][0] == 'x' && vel[2][2] == 'x')
  753.                                    if(vel[1][1] == ' ' && x){
  754.                                                    vel[1][1] = 'o';
  755.                                                    x = 0;
  756.                                    }
  757.  
  758.                  if(vel[0][0] == 'x' && vel[1][0] == 'x')
  759.                                    if(vel[2][0] == ' ' && x){
  760.                                                    vel[2][0] = 'o';
  761.                                                    x = 0;
  762.                                    }
  763.                                    
  764.                  if(vel[1][0] == 'x' && vel[2][0] == 'x')
  765.                                    if(vel[0][0] == ' ' && x){
  766.                                                    vel[0][0] = 'o';
  767.                                                    x = 0;
  768.                                    }
  769.                  
  770.                  if(vel[0][0] == 'x' && vel[2][0] == 'x')
  771.                                    if(vel[1][0] == ' ' && x){
  772.                                                    vel[1][0] = 'o';
  773.                                                    x = 0;
  774.                                    }
  775.  
  776.                  if(vel[0][1] == 'x' && vel[1][1] == 'x')
  777.                                    if(vel[2][1] == ' ' && x){
  778.                                                    vel[2][1] = 'o';
  779.                                                    x = 0;
  780.                                    }
  781.                                    
  782.                  if(vel[1][1] == 'x' && vel[2][1] == 'x')
  783.                                    if(vel[0][1] == ' ' && x){
  784.                                                    vel[0][1] = 'o';
  785.                                                    x = 0;
  786.                                    }
  787.                                    
  788.                  if(vel[0][1] == 'x' && vel[2][1] == 'x')
  789.                                    if(vel[1][1] == ' ' && x){
  790.                                                    vel[1][1] = 'o';
  791.                                                    x = 0;
  792.                                    }
  793.  
  794.                  if(vel[0][2] == 'x' && vel[1][2] == 'x')
  795.                                    if(vel[2][2] == ' ' && x){
  796.                                                    vel[2][2] = 'o';
  797.                                                     x = 0;
  798.                                    }
  799.                                    
  800.                  if(vel[1][2] == 'x' && vel[2][2] == 'x')
  801.                                    if(vel[0][2] == ' ' && x){
  802.                                                    vel[0][2] = 'o';
  803.                                                    x = 0;
  804.                                    }
  805.                                    
  806.                  if(vel[0][2] == 'x' && vel[2][2] == 'x')
  807.                                    if(vel[1][2] == ' ' && x){
  808.                                                    vel[1][2] = 'o';
  809.                                                    x = 0;
  810.                                    }
  811.  
  812.                  if(vel[0][0] == 'x' && vel[0][1] == 'x')
  813.                                    if(vel[0][2] == ' ' && x){
  814.                                                    vel[0][2] = 'o';
  815.                                                    x = 0;
  816.                                    }
  817.                                    
  818.                  if(vel[0][1] == 'x' && vel[0][2] == 'x')
  819.                                    if(vel[0][0] == ' ' && x){
  820.                                                    vel[0][0] = 'o';
  821.                                                    x = 0;
  822.                                    }
  823.                                    
  824.                  if(vel[0][0] == 'x' && vel[0][2] == 'x')
  825.                                    if(vel[0][1] == ' ' && x){
  826.                                                    vel[0][1] = 'o';
  827.                                                    x = 0;
  828.                                    }
  829.  
  830.                  if(vel[1][0] == 'x' && vel[1][1] == 'x')
  831.                                    if(vel[1][2] == ' ' && x){
  832.                                                    vel[1][2] = 'o';
  833.                                                    x = 0;
  834.                                    }
  835.                                    
  836.                  if(vel[1][1] == 'x' && vel[1][2] == 'x')
  837.                                             if(vel[1][0] == ' ' && x){
  838.                                                             vel[1][0] = 'o';
  839.                                                             x = 0;
  840.                                             }
  841.                                            
  842.                  if(vel[1][0] == 'x' && vel[1][2] == 'x')
  843.                                             if(vel[1][1] == ' ' && x){
  844.                                                             vel[1][1] = 'o';
  845.                                                             x = 0;
  846.                                             }
  847.  
  848.                  if(vel[2][0] == 'x' && vel[2][1] == 'x')
  849.                                             if(vel[2][2] == ' ' && x){
  850.                                                             vel[2][2] = 'o';
  851.                                                             x = 0;
  852.                                             }
  853.                                            
  854.                  if(vel[2][1] == 'x' && vel[2][2] == 'x')
  855.                                             if(vel[2][0] == ' ' && x){
  856.                                                             vel[2][0] = 'o';
  857.                                                             x = 0;
  858.                                             }
  859.                                            
  860.                  if(vel[2][0] == 'x' && vel[2][2] == 'x')
  861.                                             if(vel[2][1] == ' ' && x){
  862.                                                             vel[2][1] = 'o';
  863.                                                             x = 0;
  864.                                             }
  865.  
  866.                  if(vel[0][0] == 'x' && vel[1][1] == 'x' && vel[2][2] == 'o'){
  867.                                    if(x){
  868.                                          if(vel[2][0] == ' '){
  869.                                                          vel[2][0] = 'o';
  870.                                                          x = 0;
  871.                                          }
  872.                                          
  873.                                          else{
  874.                                               if(vel[0][2] == ' '){
  875.                                                               vel[0][2] = 'o';
  876.                                                               x = 0;
  877.                                               }
  878.                                          }
  879.                                    }
  880.                  }
  881.  
  882.                  if(vel[0][0] == 'x' && vel[2][1] == 'x'){
  883.                                    if(x && j2){
  884.                                         if(vel[2][0] == ' '){
  885.                                                         vel[2][0] = 'o';
  886.                                                         x = 0;
  887.                                                         j2 = 0;
  888.                                         }
  889.                                        
  890.                                         else{
  891.                                              if(vel[1][0] == ' '){
  892.                                                              vel[1][0] = 'o';
  893.                                                              x = 0;
  894.                                                              j2 = 0;
  895.                                              }
  896.                                         }
  897.                                    }
  898.                  }
  899.  
  900.                  if(vel[0][0] == 'x' && vel[1][2] == 'x'){
  901.                                    if(x && j2){
  902.                                         if(vel[0][2] == ' '){
  903.                                                         vel[0][2] = 'o';
  904.                                                         x = 0;
  905.                                                         j2 = 0;
  906.                                         }
  907.                                        
  908.                                         else{
  909.                                              if(vel[0][1] == ' '){
  910.                                                              vel[0][1] = 'o';
  911.                                                              x = 0;
  912.                                                              j2 = 0;
  913.                                              }
  914.                                         }
  915.                                    }
  916.                  }
  917.  
  918.                  if(vel[0][1] == 'x' && vel[1][0] == 'x'){
  919.                                    if(x && j2){
  920.                                         if(vel[0][0] == ' '){
  921.                                                         vel[0][0] = 'o';
  922.                                                         x = 0;
  923.                                                         j2 = 0;
  924.                                         }
  925.                                        
  926.                                         else{
  927.                                              if(vel[1][1] == ' '){
  928.                                                              vel[1][1] = 'o';
  929.                                                              x = 0;
  930.                                                              j2 = 0;
  931.                                              }
  932.                                         }
  933.                                    }
  934.                  }
  935.  
  936.                  if(vel[0][1] == 'x' && vel[2][0] == 'x'){
  937.                                    if(x && j2){
  938.                                         if(vel[1][1] == ' '){
  939.                                                         vel[1][1] = 'o';
  940.                                                         x = 0;
  941.                                                         j2 = 0;
  942.                                         }
  943.                                        
  944.                                         else{
  945.                                              if(vel[0][0] == ' '){
  946.                                                              vel[0][0] = 'o';
  947.                                                              x = 0;
  948.                                                              j2 = 0;
  949.                                              }
  950.                                         }
  951.                                    }    
  952.                  }
  953.  
  954.                  if(vel[0][1] == 'x' && vel[1][2] == 'x'){
  955.                               if(x && j2){
  956.                                    if(vel[0][2] == ' '){
  957.                                                    vel[0][2] = 'o';
  958.                                                    x = 0;
  959.                                                    j2 = 0;
  960.                                    }
  961.  
  962.                                    else{
  963.                                         if(vel[1][1] == ' '){
  964.                                                         vel[1][1] = 'o';
  965.                                                         x = 0;
  966.                                                         j2 = 0;
  967.                                         }
  968.                                    }
  969.                               }    
  970.                  }
  971.  
  972.                  if(vel[0][1] == 'x' && vel[2][2] == 'x'){
  973.                                    if(x && j2){
  974.                                         if(vel[0][2] == ' '){
  975.                                                         vel[0][2] = 'o';
  976.                                                         x = 0;
  977.                                                         j2 = 0;
  978.                                         }
  979.                                        
  980.                                         else{
  981.                                              if(vel[0][0] == ' '){
  982.                                                              vel[0][0] = 'o';
  983.                                                              x = 0;
  984.                                                              j2 = 0;
  985.                                              }
  986.                                         }
  987.                                    }
  988.                  }
  989.  
  990.                  if(vel[0][2] == 'x' && vel[1][0] == 'x'){
  991.                                    if(x && j2){
  992.                                         if(vel[0][0] == ' '){
  993.                                                      vel[0][0] = 'o';
  994.                                                      x = 0;
  995.                                                      j2 = 0;
  996.                                         }
  997.                                        
  998.                                        
  999.                                         else{
  1000.                                              if(vel[1][1] == ' '){
  1001.                                                           vel[1][1] = 'o';
  1002.                                                           x = 0;
  1003.                                                           j2 = 0;
  1004.                                              }
  1005.                                         }
  1006.                                    }
  1007.                  }
  1008.  
  1009.                  if(vel[0][2] == 'x' && vel[2][1] == 'x'){
  1010.                               if(x && j2){
  1011.                                     if(vel[2][2] == ' '){
  1012.                                                     vel[2][2] = 'o';
  1013.                                                     x = 0;
  1014.                                                     j2 = 0;
  1015.                                     }
  1016.                                    
  1017.                                     else{
  1018.                                          if(vel[1][1] == ' '){
  1019.                                                          vel[1][1] = 'o';
  1020.                                                          x = 0;
  1021.                                                          j2 = 0;
  1022.                                          }
  1023.                                     }
  1024.                               }
  1025.                  }
  1026.  
  1027.                  if(x){
  1028.                        int d = 0;
  1029.                        int f = 0;
  1030.  
  1031.                        for(d = 0; d < 3; d++){
  1032.                              for(f = 0; f < 3; f++){
  1033.                                    if(vel[d][f] == ' '){
  1034.                                    vel[d][f] = 'o';
  1035.                                    x = 0;
  1036.                              }
  1037.                              
  1038.                              if(x == 0) break;
  1039.                        }
  1040.                        
  1041.                        if(x == 0) break;
  1042.                        
  1043.                  }
  1044.  
  1045.                  if(x){
  1046.                        printf("\nEMPATE.\n");
  1047.                        resetar();
  1048.                  }
  1049.  
  1050.     }
  1051. }
  1052.  
  1053. // ----------------------------------------
  1054.  
  1055. int resetar(void)
  1056. {
  1057.     int d, f;
  1058.     for(d = 0; d < 3; d++){
  1059.              for(f = 0; f < 3; f++){
  1060.                       vel[d][f] = ' ';
  1061.              }
  1062.     }
  1063.     velha();
  1064. }
  1065.  
  1066. // ----------------------------------------
  1067.  
  1068. int velha(void)
  1069. {
  1070.     int t;
  1071.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1072.     clrscr();
  1073.     imprime();
  1074.  
  1075.     jj = 1;
  1076.     j2 = 1;
  1077.  
  1078.     do{
  1079.        lerp();
  1080.        clrscr();
  1081.        imprime();
  1082.        for(t = 0; t < 99000000; t++);
  1083.              jogapc();
  1084.              clrscr();
  1085.              imprime();
  1086.  
  1087.              if(vel[0][0]=='x' && vel[0][1]=='x' && vel[0][2]=='x' ||
  1088.                                vel[1][0]=='x' && vel[1][1]=='x' && vel[1][2]=='x' ||
  1089.                                vel[2][0]=='x' && vel[2][1]=='x' && vel[2][2]=='x' ||
  1090.  
  1091.                                vel[0][0]=='x' && vel[1][0]=='x' && vel[2][0]=='x' ||
  1092.                                vel[0][1]=='x' && vel[1][1]=='x' && vel[2][1]=='x' ||
  1093.                                vel[0][2]=='x' && vel[1][2]=='x' && vel[2][2]=='x' ||
  1094.  
  1095.                                vel[0][0]=='x' && vel[1][1]=='x' && vel[2][2]=='x' ||
  1096.                                vel[2][0]=='x' && vel[1][1]=='x' && vel[0][2]=='x') xwin();
  1097.  
  1098.              if(vel[0][0]=='o' && vel[0][1]=='o' && vel[0][2]=='o' ||
  1099.                                vel[1][0]=='o' && vel[1][1]=='o' && vel[1][2]=='o' ||
  1100.                                vel[2][0]=='o' && vel[2][1]=='o' && vel[2][2]=='o' ||
  1101.  
  1102.                                vel[0][0]=='o' && vel[1][0]=='o' && vel[2][0]=='o' ||
  1103.                                vel[0][1]=='o' && vel[1][1]=='o' && vel[2][1]=='o' ||
  1104.                                vel[0][2]=='o' && vel[1][2]=='o' && vel[2][2]=='o' ||
  1105.                                
  1106.                                vel[0][0]=='o' && vel[1][1]=='o' && vel[2][2]=='o' ||
  1107.                                vel[2][0]=='o' && vel[1][1]=='o' && vel[0][2]=='o') owin();
  1108.              }
  1109.              
  1110.         while(1);
  1111.         getch();
  1112. }
  1113.  
  1114.  
  1115. //----------------------------------------------------------------------------------
  1116.  
  1117. int bissexto(void) /* Calcular ano Bissexto */
  1118. {
  1119.     clrscr();
  1120.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1121.     int a, c, r;
  1122.     bool o;
  1123.  
  1124.     o = false;
  1125.     printf ("Digite o ano com 4 digitosa a ser calculado se \x82 Bissexto: ");
  1126.     scanf("%d", &a);
  1127.  
  1128.     if(a > 1000){
  1129.        o = true;
  1130.     }  
  1131.  
  1132.     else{  
  1133.             printf("Ano muito grande, suportado at\x82 1000");
  1134.     }  
  1135.  
  1136.     c = 4;
  1137.     r = a % c;
  1138.  
  1139.     if (r > 0){  
  1140.        printf("O ano digitado n\xc6o \x82 Bissexto");
  1141.     }  
  1142.  
  1143.     else{  
  1144.            printf("O ano digitado \x82 Bissexto");
  1145.     }
  1146.  
  1147.     getch();
  1148.     return(start());
  1149. }
  1150.  
  1151. //----------------------------------------------------------------------------------
  1152.  
  1153. int vinteum(void) /* Jogar 21 */
  1154. {
  1155.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1156.     int soma, ap, tf = 50, cartas, comp;
  1157.     char jog[30], x;
  1158.    
  1159.     clrscr();
  1160.     printf("Vamos jogar 21?\nInforme seu nome: ");
  1161.     scanf("%s", &jog);
  1162.  
  1163.     do{
  1164.        do{
  1165.        clrscr();
  1166.        soma = 0;
  1167.        comp = 0;
  1168.  
  1169.        printf("%s voc%c possui %d fichas.", jog, 136, tf);
  1170.        printf("\n\nInforme o valor de sua aposta (0 para sair): ");
  1171.        scanf("%d", &ap);
  1172.        
  1173.        if(ap == 0){
  1174.          return(games());
  1175.        }
  1176.  
  1177.    }
  1178.    
  1179.    
  1180.    while(ap > tf);
  1181.  
  1182.    do{
  1183.       clrscr();
  1184.       cartas = rand()%13 + 1;
  1185.       if(cartas > 10){
  1186.                 cartas = 10;
  1187.                 soma += cartas;
  1188.       }
  1189.      
  1190.       else
  1191.           soma += cartas;
  1192.      
  1193.       printf("%s voce j%c tem %d pontos em Cartas. (N%o pode passar de 21)", jog, 160, soma, 198);
  1194.       printf("\n\nDigite H para pegar uma carta ou S para parar: ");
  1195.       fflush(stdin);
  1196.       x = getchar();
  1197.    }
  1198.    
  1199.    while(x == 'H' || x == 'h');
  1200.    
  1201.    do{
  1202.       if(cartas + comp > 21)
  1203.                 break;
  1204.              
  1205.       cartas = rand()%13+1;
  1206.       comp += cartas;
  1207.       printf("\nO Computador fez %d pontos.", comp);
  1208.    }
  1209.    
  1210.    while(comp<20);
  1211.    if((soma > comp && soma <= 21) || (comp > 21 && soma <= 21)){
  1212.             printf ("\n\n%s voce ganhou com %d pontos.", jog, soma);
  1213.             printf("\nO computador perdeu com %d pontos.", comp);
  1214.             tf = tf + ap;
  1215.             printf("\n\nVoc%c ainda possui %d fichas para jogar.", 136, tf);
  1216.    }
  1217.  
  1218.    else
  1219.         if ((comp>soma && comp<=21)||(soma>21 && comp<=21)){
  1220.            printf("\n\nO computador ganhou com %d pontos.", comp);
  1221.            tf = tf - ap;
  1222.            printf("\n\nVoc%c perdeu com %d pontos e tem %d para apostar.", 136, soma, tf);
  1223.         }
  1224.    else
  1225.        printf("\n\nN%co houve vencedores!!!", 198);
  1226.    getch();
  1227. }
  1228.    
  1229. while(tf > 0);
  1230. printf("\nGame Over!");
  1231. getch();
  1232. return(games());
  1233. }
  1234.  
  1235.  
  1236. //----------------------------------------------------------------------------------
  1237.  
  1238. int games(void) /* Sala de Jogos */
  1239. {
  1240.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1241.     clrscr();
  1242.     int valor;
  1243.     printf("Bem-Vindo(a) a Sala de Jogos:\n\n");
  1244.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1245.     printf("1> Jogar 21.\n");
  1246.     printf("2> Jogo da Velha.\n");
  1247.     printf("3> Voltar.\n");
  1248.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  1249.     printf("> ");
  1250.     scanf("%d", &valor);
  1251.    
  1252.     switch(valor){
  1253.                   case 1:
  1254.                        return(vinteum());
  1255.                        break;
  1256.                  
  1257.                   case 2:
  1258.                        return(velha());
  1259.                  
  1260.                   case 3:
  1261.                        return(shell());
  1262.                        break;
  1263.                        
  1264.                   default:
  1265.                        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1266.                        printf("N%o encontrado.\n", 198);
  1267.                        getch();
  1268.                        return(games());
  1269.                        break;
  1270.     }              
  1271. }
  1272.  
  1273. //----------------------------------------------------------------------------------
  1274.  
  1275. int atalhos(){ /* Atalhos */
  1276.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1277.     printf("Atalhos para programas:\n\n");
  1278.     printf("raiz -> Calcular ra%cz.\n", 161);
  1279.     printf("freq -> Gerador de Frequ%cncia em Hertz.\n", 136);
  1280.     printf("romanos -> N%cmeros romanos.\n", 163);
  1281.     printf("potencia -> Calcular pot%cncia.\n", 136);
  1282.     printf("calc -> Calculadora.\n");
  1283.     printf("pi -> Calcular o PI.\n");
  1284.     printf("diasanos -> Converter dias -> anos.\n");
  1285.     printf("21 -> Jogar 21.\n");
  1286.     printf("velha -> Jogar Jogo da Velha.\n");
  1287.     printf("bix -> Calcular ano Bissexto.\n");
  1288.     return(shell());
  1289.    
  1290. }
  1291.  
  1292. //----------------------------------------------------------------------------------
  1293.  
  1294. int ajuda(void) /* Menu de Ajuda */
  1295. {
  1296.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1297.     printf("Comandos:\n\n");
  1298.     printf("help ou /? -> Comando para ajuda.\n");
  1299.     printf("atalhos -> Lista de atalhos para programas.\n");
  1300.     printf("games -> Lista de jogos.\n");
  1301.     printf("control -> Painel de Controle.\n");
  1302.     printf("exit -> Sair.\n");
  1303.     printf("reboot -> Reiniciar.\n");
  1304.     printf("version -> Vers%co do Sistema.\n", 198);
  1305.     printf("clear -> Limpar a tela.\n");
  1306.     printf("date -> Mostra a dada do sistema.\n");
  1307.     printf("logout -> Deslogar.\n");
  1308.     printf("program - Exibe lista de programas.\n");
  1309.     return(shell());
  1310. }
  1311.  
  1312. //----------------------------------------------------------------------------------
  1313.  
  1314. int control(void) /* Painel de Controle */
  1315. {
  1316.     clrscr();
  1317.     int valor;
  1318.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1319.     printf("Bem vindo(a) ao Painel de Controle do yTiny:\n\n");
  1320.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1321.     printf("1> Administrar senha.\n");
  1322.     printf("2> Voltar.\n");
  1323.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  1324.     printf("> ");
  1325.     scanf("%d", &valor);
  1326.    
  1327.     switch(valor){
  1328.                   case 1:
  1329.                        return(pwd());
  1330.                        break;
  1331.                        
  1332.                   case 2:
  1333.                        return(shell());
  1334.                        break;
  1335.                        
  1336.                   default:
  1337.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1338.                           printf("N%co encontrado.\n", 198);
  1339.                           getch();
  1340.                           return(control());
  1341.                           break;
  1342.     }
  1343. }
  1344.  
  1345. //----------------------------------------------------------------------------------
  1346.  
  1347. int pwd(void) /* Configurações da Senha */
  1348. {
  1349.     clrscr();
  1350.    
  1351.     FILE *fp;
  1352.     char string[100], c;
  1353.     int valor, i;
  1354.    
  1355.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);    
  1356.     printf("Administrar senha:\n\n");
  1357.    
  1358.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1359.     printf("1> Visualizar a senha.\n");
  1360.     printf("2> Modificar senha.\n");
  1361.     printf("3> Voltar.\n");
  1362.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  1363.     printf("> ");
  1364.     scanf("%d", &valor);
  1365.    
  1366.     switch(valor){
  1367.                   case 1:
  1368.                        fp = fopen("config/system/user/passwd.bin","rb");
  1369.                        if(!fp){
  1370.                                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1371.                                printf("\n\nErro na leitura do arquivo.\n");
  1372.                                getch();
  1373.                                return(pwd());
  1374.                        }
  1375.                        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1376.                        printf("\n\nA senha atual %c: ", 130);
  1377.                        while((c = getc(fp) ) != EOF)
  1378.                        printf("%c", c);
  1379.                        fclose(fp);
  1380.                        getch();
  1381.                        return(pwd());            
  1382.                        break;
  1383.                  
  1384.                   case 2:
  1385.                        fp = fopen("config/system/user/passwd.bin","wb");
  1386.                        if(!fp){
  1387.                                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1388.                                printf("\n\nErro na abertura do arquivo.\n");
  1389.                                getch();
  1390.                                return(pwd());
  1391.                        }
  1392.                        
  1393.                        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1394.                        printf("\n\nDigite a nova senha: ");
  1395.                        scanf("%s", &string);
  1396.                        for(i = 0; string[i]; i++) putc(string[i], fp);
  1397.                        fclose(fp);
  1398.                        printf("\nSenha alterada com sucesso.");
  1399.                        getch();
  1400.                        return(pwd());
  1401.                        break;
  1402.                        
  1403.                   case 3:
  1404.                        return(control());
  1405.                        break;
  1406.                        
  1407.                   default:
  1408.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1409.                           printf("N%co encontrado.\n", 198);
  1410.                           getch();
  1411.                           return(pwd());
  1412.                           break;
  1413.     }
  1414. }
  1415.  
  1416. //----------------------------------------------------------------------------------
  1417.  
  1418. int start(void) /* Programas */
  1419. {
  1420.     clrscr();
  1421.     int valor;
  1422.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);    
  1423.     printf("Programas:\n\n");
  1424.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1425.     printf("1> Calcular ra%cz.\n", 161);
  1426.     printf("2> Ouvir frequ%cncia em Hertz.\n", 136);
  1427.     printf("3> N%cmeros Romanos.\n", 163);
  1428.     printf("4> Calcular pot%cncia.\n", 136);
  1429.     printf("5> Calculadora.\n");
  1430.     printf("6> Calcular o PI.\n");
  1431.     printf("7> Convers%co: Dias -> Anos\n", 198);
  1432.     printf("8> Calcular ano Bissexto.\n");
  1433.     printf("9> Voltar.\n");
  1434.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  1435.     printf("> ");
  1436.     scanf("%d", &valor);
  1437.    
  1438.     switch(valor){
  1439.                   case 1:
  1440.                        return(raiz());
  1441.                        break;
  1442.                        
  1443.                   case 2:
  1444.                        return(freq());
  1445.                        break;
  1446.                        
  1447.                   case 3:
  1448.                        return(romanos());
  1449.                        break;
  1450.                        
  1451.                   case 4:
  1452.                        return(cpotencia());
  1453.                        break;
  1454.                        
  1455.                   case 5:
  1456.                        return(calculadora());
  1457.                        break;
  1458.                        
  1459.                   case 6:
  1460.                        return(pi());
  1461.                        break;
  1462.                        
  1463.                   case 7:
  1464.                        return(diasanos());
  1465.                        break;
  1466.                        
  1467.                   case 8:
  1468.                        return(bissexto());
  1469.                        
  1470.                   case 9:
  1471.                        return(shell());
  1472.                        
  1473.                   default:
  1474.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1475.                           printf("N%co encontrado.\n", 198);
  1476.                           getch();
  1477.                           return(start());
  1478.                           break;
  1479.     }
  1480. }
  1481.  
  1482. //----------------------------------------------------------------------------------
  1483.  
  1484. int diasanos(void) /* Converter Dias -> Anos */
  1485. {
  1486.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1487.     clrscr();
  1488.     int Dias;          
  1489.     float Anos;
  1490.     printf ("Entre com o numero de dias: ");
  1491.     scanf ("%d",&Dias);
  1492.     Anos = Dias/365.25;      
  1493.     printf ("\n\n%d dias equivalem a %f anos.\n",Dias,Anos);
  1494.     getch();
  1495.     return(start());
  1496. }
  1497.  
  1498. //----------------------------------------------------------------------------------
  1499.  
  1500. int raiz(void) /* Calcular Raíz */  
  1501. {
  1502.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1503.     clrscr();
  1504.     float y, x;
  1505.     printf("Digite o n%cmero do qual deseja saber a Ra%cz Quadrada:\n", 163, 161);
  1506.     scanf("%f", &x);
  1507.     y = sqrt(x);
  1508.     printf("A ra%cz quadrada e: %1.f\n", 161, y);
  1509.     getch();
  1510.     return(start());
  1511. }
  1512.  
  1513. //---------------------------------------------------------------------------------------------------------------------------
  1514.  
  1515. int freq(void) /* Frequencia em Hertz */
  1516. {
  1517.   int v;
  1518.   clrscr();
  1519.   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1520.   printf("Gerador de Frequencia em Hertz:\n\n");
  1521.   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1522.   printf("1> Executar.\n");
  1523.   printf("2> Voltar.\n");
  1524.   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  1525.   printf("> ");
  1526.   scanf("%d", &v);
  1527.  
  1528.   switch(v){
  1529.             case 1:
  1530.                  return(freq1());
  1531.                  break;
  1532.                  
  1533.             case 2:
  1534.                  return(start());
  1535.                  break;
  1536.                  
  1537.             default:
  1538.                     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1539.                     printf("N%co encontrado.\n", 198);
  1540.                     getch();
  1541.                     return(freq());
  1542.                     break;
  1543.   }
  1544.   exit(0);
  1545. }
  1546.  
  1547. //----------------------
  1548.  
  1549. int freq1(void)
  1550. {
  1551.   clrscr();
  1552.   int i, tempo, freq;
  1553.   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1554.   printf("Escolha o tempo de execu%cao do toque em segundos, exemplo: 10\n", 135);
  1555.   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  1556.   printf("> ");
  1557.   scanf("%d", &tempo);
  1558.  
  1559.   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1560.   printf("\nEscolha a frequ%cncia em Hertz, exemplo: 2600\n> ", 136);
  1561.   scanf("%d", &freq);
  1562.  
  1563.   for(i = 0; i < tempo; i++){
  1564.       clrscr();
  1565.       printf("Reproduzindo...");
  1566.       printf("\nTempo de Reprodu%cao escolhido: %d segundos.", 135, tempo);
  1567.       printf("\nFrequ%cncia em Hertz escolhida: %d Hz.", 136, freq);
  1568.       Beep(freq, 1000);
  1569.   }
  1570.  
  1571.   clrscr();
  1572.   printf("by: ScR1pT.NET\n");
  1573.   getch();
  1574.   return(start());
  1575. }
  1576.  
  1577. //---------------------------------------------------------------------------------------------------------------------------
  1578.  
  1579. int romanos(void) /* Números Romanos */
  1580. {
  1581.            int valor;
  1582.            clrscr();
  1583.            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  1584.            printf("Digite o n%cmero que deseja saber em Romano. (OBS: Ate 100):\n", 163);
  1585.            scanf("%d", &valor);
  1586.            
  1587.            switch(valor){
  1588.                          SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  1589.                          case 1:
  1590.                               clrscr();
  1591.                               printf("1 => I\n");
  1592.                               getch();
  1593.                               return(start());
  1594.                               break;
  1595.                              
  1596.                          case 2:
  1597.                               clrscr();
  1598.                               printf("2 => II\n");
  1599.                               getch();
  1600.                               return(start());
  1601.                               break;
  1602.                              
  1603.                          case 3:
  1604.                               clrscr();
  1605.                               printf("3 => III\n");
  1606.                               getch();
  1607.                               return(start());
  1608.                               break;
  1609.                              
  1610.                          case 4:
  1611.                               clrscr();
  1612.                               printf("4 => IV\n");
  1613.                               getch();
  1614.                               return(start());
  1615.                               break;
  1616.                              
  1617.                          case 5:
  1618.                               clrscr();
  1619.                               printf("5 => V\n");
  1620.                               getch();
  1621.                               return(start());
  1622.                               break;
  1623.                          
  1624.                          case 6:
  1625.                               clrscr();
  1626.                               printf("6 => VI\n");
  1627.                               getch();
  1628.                               return(start());
  1629.                               break;
  1630.                              
  1631.                          case 7:
  1632.                               clrscr();
  1633.                               printf("7 => VII\n");
  1634.                               getch();
  1635.                               return(start());
  1636.                               break;
  1637.                              
  1638.                          case 8:
  1639.                               clrscr();
  1640.                               printf("8 => VIII\n");
  1641.                               getch();
  1642.                               return(start());
  1643.                               break;
  1644.                              
  1645.                          case 9:
  1646.                               clrscr();
  1647.                               printf("9 => IX\n");
  1648.                               getch();
  1649.                               return(start());
  1650.                               break;
  1651.                              
  1652.                          case 10:
  1653.                               clrscr();
  1654.                               printf("10 => X\n");
  1655.                               getch();
  1656.                               return(start());
  1657.                               break;
  1658.                              
  1659.                          case 11:
  1660.                               clrscr();
  1661.                               printf("11 => XI\n");
  1662.                               getch();
  1663.                               return(start());
  1664.                               break;
  1665.                              
  1666.                          case 12:
  1667.                               clrscr();
  1668.                               printf("12 => XII\n");
  1669.                               getch();
  1670.                               return(start());
  1671.                               break;
  1672.                              
  1673.                          case 13:
  1674.                               clrscr();
  1675.                               printf("13 => XIII\n");
  1676.                               getch();
  1677.                               return(start());
  1678.                               break;
  1679.                              
  1680.                          case 14:
  1681.                               clrscr();
  1682.                               printf("14 => XIV\n");
  1683.                               getch();
  1684.                               return(start());
  1685.                               break;
  1686.                              
  1687.                          case 15:
  1688.                               clrscr();
  1689.                               printf("15 => XV\n");
  1690.                               getch();
  1691.                               return(start());
  1692.                               break;
  1693.                              
  1694.                          case 16:
  1695.                               clrscr();
  1696.                               printf("16 => XVI\n");
  1697.                               getch();
  1698.                               return(start());
  1699.                               break;
  1700.                              
  1701.                          case 17:
  1702.                               clrscr();
  1703.                               printf("17 => XVII\n");
  1704.                               getch();
  1705.                               return(start());
  1706.                               break;
  1707.                              
  1708.                          case 18:
  1709.                               clrscr();
  1710.                               printf("18 => XVIII\n");
  1711.                               getch();
  1712.                               return(start());
  1713.                               break;
  1714.                              
  1715.                          case 19:
  1716.                               clrscr();
  1717.                               printf("19 => XIX\n");
  1718.                               getch();
  1719.                               return(start());
  1720.                               break;
  1721.                              
  1722.                          case 20:
  1723.                               clrscr();
  1724.                               printf("20 => XX\n");
  1725.                               getch();
  1726.                               return(start());
  1727.                               break;
  1728.                              
  1729.                          case 21:
  1730.                               clrscr();
  1731.                               printf("21 => XXI\n");
  1732.                               getch();
  1733.                               return(start());
  1734.                               break;
  1735.                              
  1736.                          case 22:
  1737.                               clrscr();
  1738.                               printf("22 => XXII\n");
  1739.                               getch();
  1740.                               return(start());
  1741.                               break;
  1742.                              
  1743.                          case 23:
  1744.                               clrscr();
  1745.                               printf("23 => XXIII\n");
  1746.                               getch();
  1747.                               return(start());
  1748.                               break;
  1749.                              
  1750.                          case 24:
  1751.                               clrscr();
  1752.                               printf("24 => XXIV\n");
  1753.                               getch();
  1754.                               return(start());
  1755.                               break;
  1756.                              
  1757.                          case 25:
  1758.                               clrscr();
  1759.                               printf("25 => XXV\n");
  1760.                               getch();
  1761.                               return(start());
  1762.                               break;
  1763.                          
  1764.                          case 26:
  1765.                               clrscr();
  1766.                               printf("26 => XXVI\n");
  1767.                               getch();
  1768.                               return(start());
  1769.                               break;
  1770.                              
  1771.                          case 27:
  1772.                               clrscr();
  1773.                               printf("27 => XXVII\n");
  1774.                               getch();
  1775.                               return(start());
  1776.                               break;
  1777.                              
  1778.                          case 28:
  1779.                               clrscr();
  1780.                               printf("28 => XXVIII\n");
  1781.                               getch();
  1782.                               return(start());
  1783.                               break;
  1784.                              
  1785.                          case 29:
  1786.                               clrscr();
  1787.                               printf("29 => XXIX\n");
  1788.                               getch();
  1789.                               return(start());
  1790.                               break;
  1791.                              
  1792.                          case 30:
  1793.                               clrscr();
  1794.                               printf("30 => XXX\n");
  1795.                               getch();
  1796.                               return(start());
  1797.                               break;
  1798.                              
  1799.                          case 31:
  1800.                               clrscr();
  1801.                               printf("31 => XXXI\n");
  1802.                               getch();
  1803.                               return(start());
  1804.                               break;
  1805.                              
  1806.                          case 32:
  1807.                               clrscr();
  1808.                               printf("32 => XXXII\n");
  1809.                               getch();
  1810.                               return(start());
  1811.                               break;
  1812.                              
  1813.                          case 33:
  1814.                               clrscr();
  1815.                               printf("33 => XXXIII\n");
  1816.                               getch();
  1817.                               return(start());
  1818.                               break;
  1819.                              
  1820.                          case 34:
  1821.                               clrscr();
  1822.                               printf("34 => XXXIV\n");
  1823.                               getch();
  1824.                               return(start());
  1825.                               break;
  1826.                              
  1827.                          case 35:
  1828.                               clrscr();
  1829.                               printf("35 => XXXV\n");
  1830.                               getch();
  1831.                               return(start());
  1832.                               break;
  1833.                              
  1834.                          case 36:
  1835.                               clrscr();
  1836.                               printf("36 => XXXVI\n");
  1837.                               getch();
  1838.                               return(start());
  1839.                               break;
  1840.                              
  1841.                          case 37:
  1842.                               clrscr();
  1843.                               printf("37 => XXXVII\n");
  1844.                               getch();
  1845.                               return(start());
  1846.                               break;
  1847.                              
  1848.                          case 38:
  1849.                               clrscr();
  1850.                               printf("38 => XXXVIII\n");
  1851.                               getch();
  1852.                               return(start());
  1853.                               break;
  1854.                              
  1855.                          case 39:
  1856.                               clrscr();
  1857.                               printf("39 => XXXIX\n");
  1858.                               getch();
  1859.                               return(start());
  1860.                               break;
  1861.                              
  1862.                          case 40:
  1863.                               clrscr();
  1864.                               printf("40 => XL\n");
  1865.                               getch();
  1866.                               return(start());
  1867.                               break;
  1868.                              
  1869.                          case 41:
  1870.                               clrscr();
  1871.                               printf("41 => XLI\n");
  1872.                               getch();
  1873.                               return(start());
  1874.                               break;
  1875.                              
  1876.                          case 42:
  1877.                               clrscr();
  1878.                               printf("42 => XLII\n");
  1879.                               getch();
  1880.                               return(start());
  1881.                               break;
  1882.                              
  1883.                          case 43:
  1884.                               clrscr();
  1885.                               printf("43 => XLIII\n");
  1886.                               getch();
  1887.                               return(start());
  1888.                               break;
  1889.                              
  1890.                          case 44:
  1891.                               clrscr();
  1892.                               printf("44 => XLIV\n");
  1893.                               getch();
  1894.                               return(start());
  1895.                               break;
  1896.                              
  1897.                          case 45:
  1898.                               clrscr();
  1899.                               printf("5 => XLV\n");
  1900.                               getch();
  1901.                               return(start());
  1902.                               break;
  1903.                          
  1904.                          case 46:
  1905.                               clrscr();
  1906.                               printf("46 => XLVI\n");
  1907.                               getch();
  1908.                               return(start());
  1909.                               break;
  1910.                              
  1911.                          case 47:
  1912.                               clrscr();
  1913.                               printf("47 => XLVII\n");
  1914.                               getch();
  1915.                               return(start());
  1916.                               break;
  1917.                              
  1918.                          case 48:
  1919.                               clrscr();
  1920.                               printf("48 => XLVIII\n");
  1921.                               getch();
  1922.                               return(start());
  1923.                               break;
  1924.                              
  1925.                          case 49:
  1926.                               clrscr();
  1927.                               printf("49 => XLIX\n");
  1928.                               getch();
  1929.                               return(start());
  1930.                               break;
  1931.                              
  1932.                          case 50:
  1933.                               clrscr();
  1934.                               printf("50 => L\n");
  1935.                               getch();
  1936.                               return(start());
  1937.                               break;
  1938.                              
  1939.                          case 51:
  1940.                               clrscr();
  1941.                               printf("51 => LI\n");
  1942.                               getch();
  1943.                               return(start());
  1944.                               break;
  1945.                              
  1946.                          case 52:
  1947.                               clrscr();
  1948.                               printf("52 => LXII\n");
  1949.                               getch();
  1950.                               return(start());
  1951.                               break;
  1952.                              
  1953.                          case 53:
  1954.                               clrscr();
  1955.                               printf("53 => LXIII\n");
  1956.                               getch();
  1957.                               return(start());
  1958.                               break;
  1959.                              
  1960.                          case 54:
  1961.                               clrscr();
  1962.                               printf("54 => LXIV\n");
  1963.                               getch();
  1964.                               return(start());
  1965.                               break;
  1966.                              
  1967.                          case 55:
  1968.                               clrscr();
  1969.                               printf("55 => LV\n");
  1970.                               getch();
  1971.                               return(start());
  1972.                               break;
  1973.                              
  1974.                          case 56:
  1975.                               clrscr();
  1976.                               printf("56 => LVI\n");
  1977.                               getch();
  1978.                               return(start());
  1979.                               break;
  1980.                              
  1981.                          case 57:
  1982.                               clrscr();
  1983.                               printf("57 => LVII\n");
  1984.                               getch();
  1985.                               return(start());
  1986.                               break;
  1987.                              
  1988.                          case 58:
  1989.                               clrscr();
  1990.                               printf("58 => LVIII\n");
  1991.                               getch();
  1992.                               return(start());
  1993.                               break;
  1994.                              
  1995.                          case 59:
  1996.                               clrscr();
  1997.                               printf("59 => LIX\n");
  1998.                               getch();
  1999.                               return(start());
  2000.                               break;
  2001.                              
  2002.                          case 60:
  2003.                               clrscr();
  2004.                               printf("60 => LX\n");
  2005.                               getch();
  2006.                               return(start());
  2007.                               break;
  2008.                              
  2009.                          case 61:
  2010.                               clrscr();
  2011.                               printf("61 => LXI\n");
  2012.                               getch();
  2013.                               return(start());
  2014.                               break;
  2015.                              
  2016.                          case 62:
  2017.                               clrscr();
  2018.                               printf("62 => LXII\n");
  2019.                               getch();
  2020.                               return(start());
  2021.                               break;
  2022.                              
  2023.                          case 63:
  2024.                               clrscr();
  2025.                               printf("63 => LXIII\n");
  2026.                               getch();
  2027.                               return(start());
  2028.                               break;
  2029.                              
  2030.                          case 64:
  2031.                               clrscr();
  2032.                               printf("64 => LXIV\n");
  2033.                               getch();
  2034.                               return(start());
  2035.                               break;
  2036.                              
  2037.                          case 65:
  2038.                               clrscr();
  2039.                               printf("65 => LXV\n");
  2040.                               getch();
  2041.                               return(start());
  2042.                               break;
  2043.                          
  2044.                          case 66:
  2045.                               clrscr();
  2046.                               printf("66 => LXVI\n");
  2047.                               getch();
  2048.                               return(start());
  2049.                               break;
  2050.                              
  2051.                          case 67:
  2052.                               clrscr();
  2053.                               printf("67 => LXVII\n");
  2054.                               getch();
  2055.                               return(start());
  2056.                               break;
  2057.                              
  2058.                          case 68:
  2059.                               clrscr();
  2060.                               printf("68 => LXVIII\n");
  2061.                               getch();
  2062.                               return(start());
  2063.                               break;
  2064.                              
  2065.                          case 69:
  2066.                               clrscr();
  2067.                               printf("69 => LXIX\n");
  2068.                               getch();
  2069.                               return(start());
  2070.                               break;
  2071.                              
  2072.                          case 70:
  2073.                               clrscr();
  2074.                               printf("70 => LXX\n");
  2075.                               getch();
  2076.                               return(start());
  2077.                               break;
  2078.                              
  2079.                          case 71:
  2080.                               clrscr();
  2081.                               printf("71 => LXXI\n");
  2082.                               getch();
  2083.                               return(start());
  2084.                               break;
  2085.                              
  2086.                          case 72:
  2087.                               clrscr();
  2088.                               printf("72 => LXXII\n");
  2089.                               getch();
  2090.                               return(start());
  2091.                               break;
  2092.                              
  2093.                          case 73:
  2094.                               clrscr();
  2095.                               printf("73 => LXXIII\n");
  2096.                               getch();
  2097.                               return(start());
  2098.                               break;
  2099.                              
  2100.                          case 74:
  2101.                               clrscr();
  2102.                               printf("74 => LXXIV\n");
  2103.                               getch();
  2104.                               return(start());
  2105.                               break;
  2106.                              
  2107.                          case 75:
  2108.                               clrscr();
  2109.                               printf("75 => LXXV\n");
  2110.                               getch();
  2111.                               return(start());
  2112.                               break;
  2113.                              
  2114.                          case 76:
  2115.                               clrscr();
  2116.                               printf("76 => LXXVI\n");
  2117.                               getch();
  2118.                               return(start());
  2119.                               break;
  2120.                              
  2121.                          case 77:
  2122.                               clrscr();
  2123.                               printf("77 => LXXVII\n");
  2124.                               getch();
  2125.                               return(start());
  2126.                               break;
  2127.                              
  2128.                          case 78:
  2129.                               clrscr();
  2130.                               printf("78 => LXXVIII\n");
  2131.                               getch();
  2132.                               return(start());
  2133.                               break;
  2134.                              
  2135.                          case 79:
  2136.                               clrscr();
  2137.                               printf("79 => LXXIX\n");
  2138.                               getch();
  2139.                               return(start());
  2140.                               break;
  2141.                              
  2142.                          case 80:
  2143.                               clrscr();
  2144.                               printf("80 => LXXX\n");
  2145.                               getch();
  2146.                               return(start());
  2147.                               break;
  2148.                              
  2149.                          case 81:
  2150.                               clrscr();
  2151.                               printf("81 => LXXXI\n");
  2152.                               getch();
  2153.                               return(start());
  2154.                               break;
  2155.                              
  2156.                          case 82:
  2157.                               clrscr();
  2158.                               printf("82 => LXXXII\n");
  2159.                               getch();
  2160.                               return(start());
  2161.                               break;
  2162.                              
  2163.                          case 83:
  2164.                               clrscr();
  2165.                               printf("83 => LXXXIII\n");
  2166.                               getch();
  2167.                               return(start());
  2168.                               break;
  2169.                              
  2170.                          case 84:
  2171.                               clrscr();
  2172.                               printf("84 => LXXXIV\n");
  2173.                               getch();
  2174.                               return(start());
  2175.                               break;
  2176.                              
  2177.                          case 85:
  2178.                               clrscr();
  2179.                               printf("85 => LXXXV\n");
  2180.                               getch();
  2181.                               return(start());
  2182.                               break;
  2183.                          
  2184.                          case 86:
  2185.                               clrscr();
  2186.                               printf("86 => LXXXVI\n");
  2187.                               getch();
  2188.                               return(start());
  2189.                               break;
  2190.                              
  2191.                          case 87:
  2192.                               clrscr();
  2193.                               printf("87 => LXXXVII\n");
  2194.                               getch();
  2195.                               return(start());
  2196.                               break;
  2197.                              
  2198.                          case 88:
  2199.                               clrscr();
  2200.                               printf("88 => LXXXVIII\n");
  2201.                               getch();
  2202.                               return(start());
  2203.                               break;
  2204.                              
  2205.                          case 89:
  2206.                               clrscr();
  2207.                               printf("89 => LXXXIX\n");
  2208.                               getch();
  2209.                               return(start());
  2210.                               break;
  2211.                              
  2212.                          case 90:
  2213.                               clrscr();
  2214.                               printf("90 => XC\n");
  2215.                               getch();
  2216.                               return(start());
  2217.                               break;
  2218.                              
  2219.                          case 91:
  2220.                               clrscr();
  2221.                               printf("91 => XCI\n");
  2222.                               getch();
  2223.                               return(start());
  2224.                               break;
  2225.                              
  2226.                          case 92:
  2227.                               clrscr();
  2228.                               printf("92 => XCII\n");
  2229.                               getch();
  2230.                               return(start());
  2231.                               break;
  2232.                              
  2233.                          case 93:
  2234.                               clrscr();
  2235.                               printf("93 => XCIII\n");
  2236.                               getch();
  2237.                               return(start());
  2238.                               break;
  2239.                              
  2240.                          case 94:
  2241.                               clrscr();
  2242.                               printf("94 => XCIV\n");
  2243.                               getch();
  2244.                               return(start());
  2245.                               break;
  2246.                              
  2247.                          case 95:
  2248.                               clrscr();
  2249.                               printf("95 => XCV\n");
  2250.                               getch();
  2251.                               return(start());
  2252.                               break;
  2253.                              
  2254.                          case 96:
  2255.                               clrscr();
  2256.                               printf("96 => XCI\n");
  2257.                               getch();
  2258.                               return(start());
  2259.                               break;
  2260.                              
  2261.                          case 97:
  2262.                               clrscr();
  2263.                               printf("97 => XCII\n");
  2264.                               getch();
  2265.                               return(start());
  2266.                               break;
  2267.                              
  2268.                          case 98:
  2269.                               clrscr();
  2270.                               printf("98 => XCIII\n");
  2271.                               getch();
  2272.                               return(start());
  2273.                               break;
  2274.                              
  2275.                          case 99:
  2276.                               clrscr();
  2277.                               printf("99 => XCIX\n");
  2278.                               getch();
  2279.                               return(start());
  2280.                               break;
  2281.                              
  2282.                          case 100:
  2283.                               clrscr();
  2284.                               printf("100 => C\n");
  2285.                               getch();
  2286.                               return(start());
  2287.                               break;
  2288.                              
  2289.                          default:
  2290.                              SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  2291.                              printf("N%co encontrado.\n", 198);
  2292.                              getch();
  2293.                              return(romanos());
  2294.                              break;
  2295.                          }
  2296.  
  2297. exit(0);
  2298. }
  2299.  
  2300. //---------------------------------------------------------------------------------------------------------------------------
  2301.  
  2302. int cpotencia(void) /* Calcular Potência */
  2303. {
  2304.     int a, b;
  2305.     float d;
  2306.     clrscr();
  2307.     printf("Digite o n%cmero que ser%c Potenciado:\n", 163, 160);
  2308.     scanf("%d", &a);
  2309.     printf("\n\nDigite o Expoente:\n");
  2310.     scanf("%d", &b);
  2311.     d = pow(a, b);
  2312.     printf("\n\nResultado: %2.f\n", d);
  2313.     getch();
  2314.     return(start());
  2315. }
  2316.  
  2317. //---------------------------------------------------------------------------------------------------------------------------
  2318.  
  2319. int calculadora(void) /* Calculadora */
  2320. {
  2321. clrscr();
  2322. char valor;
  2323. int a,b,c;
  2324. int d,e,f;
  2325. float g,h,i;
  2326. int j,k,l;
  2327.        
  2328.        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);      
  2329.        printf("Escolha:\n\n");
  2330.        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2331.        printf("1> Adi%c%co\n", 135, 198);
  2332.        printf("2> Subtra%c%co\n", 135, 198);
  2333.        printf("3> Multiplica%c%co\n", 135, 198);
  2334.        printf("4> Divis%co\n", 198);
  2335.        printf("5> Voltar\n");
  2336.        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  2337.        printf("> ");
  2338.        scanf("%d",&valor);
  2339.  
  2340.    switch(valor)
  2341.           {
  2342.                      case 1:
  2343.                             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2344.                             printf("\nDigite o valor:\n");
  2345.                             scanf("%d", &a);
  2346.                             printf("\nDigite outro valor:\n");
  2347.                             scanf("%d", &b);
  2348.                             c = a + b;
  2349.                             printf("\nResultado: %d.\n\a", a+b);
  2350.                             break;
  2351.                            
  2352.                      case 2:
  2353.                              SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2354.                              printf("\nDigite o valor:\n");
  2355.                              scanf("%d", &d);
  2356.                              printf("\nDigite outro valor:\n");
  2357.                              scanf("%d", &e);
  2358.                              f = d-e;
  2359.                              printf("\nResultado: %d.\n", d-e);
  2360.                              break;
  2361.                              
  2362.                      case 3:
  2363.                             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2364.                             printf("\nDigite o valor:\n");
  2365.                             scanf("%f",&g);
  2366.                             printf("\nDigite outro valor:\n");
  2367.                             scanf("%f",&h);
  2368.                             i = g*h;
  2369.                             printf("\nResultado %2.f.\n", i);
  2370.                             break;
  2371.                                    
  2372.                      case 4:
  2373.                             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2374.                             printf("\nDigite o valor:\n");
  2375.                             scanf("%d",&j);
  2376.                             printf("\nDigite outro valor:\n");
  2377.                             scanf("%d",&k);
  2378.                             l = j/k;
  2379.                             printf("\nResultado %d.\n\n", j/k);
  2380.                             break;
  2381.                                          
  2382.                      case 5:
  2383.                             return(start());
  2384.                             break;
  2385.                            
  2386.                      default:
  2387.                           SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);  
  2388.                           printf("N%co encontrado.\n", 198);
  2389.                           getch();
  2390.                           return(calculadora());
  2391.                           break;
  2392.                      }
  2393.                                          
  2394. getch();
  2395. return(start());
  2396. }
  2397.  
  2398. //---------------------------------------------------------------------------------------------------------------------------
  2399.  
  2400. int pi(void) /* Calcular o PI */
  2401. {    
  2402.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2403.     int raio, diam, num, a;
  2404.            
  2405.     clrscr();
  2406.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  2407.     printf("Escolha uma op%cao no menu abaixo: (OBS: PI = 3)\n", 135);
  2408.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2409.     printf("1> Calcular a partir do Di%cmetro.\n", 131);
  2410.     printf("2> Calcular a partir do Raio.\n");
  2411.     printf("3> Calcular %crea de uma Circunfer%cncia.\n", 160, 136);
  2412.     printf("4> Voltar.\n");
  2413.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_BLUE);
  2414.     printf("> ");
  2415.     scanf("%d", &num);
  2416.    
  2417.     switch(num)
  2418.     {
  2419.                
  2420.                 case 1:
  2421.                      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2422.                      clrscr();
  2423.                      printf("Qual o Di%cmetro?\a\n", 131);
  2424.                      scanf("%d", &diam);
  2425.                      clrscr();
  2426.                      printf("C = 2 * PI * r\n");
  2427.                      raio = diam / 2;
  2428.                      printf("C = 6,28 * %d", raio);
  2429.                      a = raio * 6,28;
  2430.                      printf("\nC = %d\n", a);
  2431.                      getch();
  2432.                      break;
  2433.                      
  2434.                 case 2:
  2435.                      SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2436.                      clrscr();
  2437.                      printf("Qual o Raio?\n\a");
  2438.                      scanf("%d", &raio);
  2439.                      clrscr();
  2440.                      printf("C = 2 * PI * r");
  2441.                      printf("\nC = 6,28 * %d", raio);
  2442.                      a = raio * 6,28;
  2443.                      printf("\nC = %d\n", a);
  2444.                      getch();
  2445.                      break;
  2446.                      
  2447.                 case 3:
  2448.                      return(area());
  2449.                      
  2450.                 case 4:
  2451.                      return(start());
  2452.                      break;
  2453.                      
  2454.                 default:
  2455.                         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
  2456.                         printf("N%co encontrado.\n", 198);
  2457.                         getch();
  2458.                         return(pi());
  2459.                         break;
  2460.                 }
  2461.                
  2462. return(start());
  2463. }
  2464.  
  2465. //---------------------------------------------------------------------------------------------------------------------------
  2466.  
  2467. int area(void)
  2468. {
  2469.     float raio;
  2470.     float area;
  2471.     clrscr();
  2472.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  2473.     printf ("Digite o raio do seu circulo:\n\r");
  2474.     scanf ("%f", &raio);
  2475.     area = (raio*raio)*PI;
  2476.     clrscr();
  2477.     printf("A = PI * r2\n");
  2478.     printf("A = 3 * %.2f",raio);
  2479.     printf("\nA = %.2f",area);
  2480.     printf("\nA %crea do seu circulo e: %.2f cm\n", 160, area);
  2481.     getch();
  2482.     return(pi());
  2483. }
  2484.  
  2485. //----------------------------------------------------------------------------------
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!