API tools faq
paste
Guest User

Fonctions

a guest
Feb 19th, 2017
485
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 51.69 KB | None | 0 0
raw download clone embed print report
  1. char *nullString ( char string[], int length )
  2. {
  3.     int x = 0;
  4.  
  5.     for ( x = 0; x < length; x++)
  6.         string[i] = '/0';
  7.  
  8.     return string;
  9. }
  10.  
  11. char *SHA512_binToHex(unsigned char input[], unsigned char output[], _Bool withSpace)
  12. {
  13.     int x = 0;
  14.     char stringTemp[16] = { 0 };
  15.  
  16.     nullString(output, 129);
  17.  
  18.     if (withSpace)
  19.     {
  20.         for (x = 0; x < 64; x++)
  21.         {
  22.             sprintf(stringTemp, "%2X", input[x]);
  23.             strcat(output, stringTemp);
  24.         }
  25.     }
  26.     else
  27.     {
  28.         for (x = 0; x < 64; x++)
  29.         {
  30.             sprintf(stringTemp, "%X", input[x]);
  31.             strcat(output, stringTemp);
  32.         }
  33.     }
  34.  
  35.     return (output);
  36. }
  37.  
  38. void subtitChar(char *string, int stringLength, char charToSubtit, char alpha)
  39. {
  40.     int x = 0;
  41.  
  42.     for (x = 0; x < stringLength; x++)
  43.     if (string[x] == charToSubtit)
  44.         string[x] = alpha;
  45. }
  46.  
  47. char *stringAdd(char source[], const char input[])
  48. {
  49.     int i = 0;
  50.  
  51.     int sourceLength = strlen(source);
  52.     int inputLength = strlen(input);
  53.  
  54.     if (inputLength < sourceLength)
  55.     {
  56.         for (i = 0; i < sourceLength; i++)
  57.             source[i] += input[i%inputLength];
  58.     }
  59.     else if (inputLength == sourceLength)
  60.     {
  61.         for (i = 0; i < sourceLength; i++)
  62.             source[i] += input[i];
  63.     }
  64.     else
  65.     {
  66.         for (i = 0; i < inputLength; i++)
  67.             source[i%sourceLength] += input[i];
  68.     }
  69.  
  70.     return (source);
  71. }
  72.  
  73. char *stringXOR(char source[], const char mask[])
  74. {
  75.     int i = 0;
  76.  
  77.     int sourceLength = strlen(source);
  78.     int maskLength = strlen(mask);
  79.  
  80.     if (maskLength < sourceLength)
  81.     {
  82.         for (i = 0; i < sourceLength; i++)
  83.             source[i] ^= mask[i%maskLength];
  84.     }
  85.     else if (maskLength == sourceLength)
  86.     {
  87.         for (i = 0; i < sourceLength; i++)
  88.             source[i] ^= mask[i];
  89.     }
  90.     else
  91.     {
  92.         for (i = 0; i < maskLength; i++)
  93.             source[i%sourceLength] ^= mask[i];
  94.     }
  95.  
  96.     return (source);
  97. }
  98.  
  99. char *tri_dimensionnalShaker(char string[], int x_Variations, int y_Variations, int z_Variations, _Bool isReverse)
  100. {
  101.     int mod = 0;
  102.     int mod_3 = 0;
  103.  
  104.     int x_dim = 0;
  105.     int y_dim = 0;
  106.     int z_dim = 0;
  107.  
  108.     int x_VariationsTourDone = 0;
  109.     int y_VariationsTourDone = 0;
  110.     int z_VariationsTourDone = 0;
  111.  
  112.     int x_VariationsBackup = x_Variations;
  113.     int y_VariationsBackup = y_Variations;
  114.     int z_VariationsBackup = z_Variations;
  115.  
  116.     int stringLength = strlen(string);
  117.  
  118.     int w = 0;
  119.     int x = 0;
  120.     int y = 0;
  121.     int z = 0;
  122.  
  123.     char string_temp[64] = { 0 };
  124.  
  125.     char *stringDecrypted = NULL;
  126.     stringDecrypted = malloc(sizeof(char*)*stringLength);
  127.     for (x = 0; x < stringLength; x++)
  128.         stringDecrypted[x] = '\0';
  129.  
  130.     if (!isReverse)
  131.     {
  132.         while (z_dim*y_dim*x_dim < stringLength)
  133.         {
  134.             if (!(mod_3 % 3))
  135.                 x_dim++;
  136.             else if (mod_3 % 3 == 1)
  137.                 y_dim++;
  138.             else
  139.                 z_dim++;
  140.  
  141.             mod_3++;
  142.         }
  143.         if ((x_dim > y_dim&&x_dim >= z_dim) || (x_dim >= y_dim&&x_dim > z_dim))
  144.         {
  145.             y_dim = x_dim;
  146.             z_dim = x_dim;
  147.         }
  148.         else if ((y_dim > x_dim&&y_dim >= z_dim) || (y_dim >= x_dim&&y_dim > z_dim))
  149.         {
  150.             x_dim = y_dim;
  151.             z_dim = y_dim;
  152.         }
  153.         else if ((z_dim > x_dim&&z_dim >= y_dim) || (z_dim >= x_dim&&z_dim > y_dim))
  154.         {
  155.             x_dim = z_dim;
  156.             y_dim = z_dim;
  157.         }
  158.  
  159.         char ****stringMatrix = NULL;
  160.         stringMatrix = malloc(sizeof(char****)* z_dim);
  161.  
  162.         for (y = 0; y < y_dim; y++)
  163.             stringMatrix[y] = malloc(sizeof(char***)*y_dim);
  164.  
  165.         for (y = 0; y < y_dim; y++)
  166.         for (x = 0; x < x_dim; x++)
  167.             stringMatrix[y][x] = malloc(sizeof(char**)*x_dim);
  168.  
  169.         for (z = 0; z < z_dim; z++)
  170.         for (y = 0; y < y_dim; y++)
  171.         for (x = 0; x < x_dim; x++)
  172.             stringMatrix[z][y][x] = malloc((sizeof(char*)) * 3);
  173.  
  174.         for (z = 0; z < z_dim; z++)
  175.         {
  176.             for (y = 0; y < y_dim; y++)
  177.             {
  178.                 for (x = 0; x < x_dim; x++)
  179.                 {
  180.                     stringMatrix[z][y][x][0] = '\0';
  181.                     stringMatrix[z][y][x][1] = '\0';
  182.                     stringMatrix[z][y][x][2] = '\0';
  183.                 }
  184.             }
  185.         }
  186.  
  187.         w = 0;
  188.         for (z = 0; z < z_dim; z++)
  189.         {
  190.             for (y = 0; y < y_dim; y++)
  191.             {
  192.                 for (x = 0; x < x_dim; x++)
  193.                 {
  194.                     if (w>strlen(string))
  195.                         sprintf(stringMatrix[z][y][x], "KK");
  196.                     else
  197.                     {
  198.                         if (string[w] == '\0')
  199.                             sprintf(stringMatrix[z][y][x], "KK");
  200.                         else
  201.                         {
  202.                             sprintf(string_temp, "%c", string[w]);;
  203.                             sprintf(stringMatrix[z][y][x], "%s", string_temp);
  204.                         }
  205.                     }
  206.                     w++;
  207.                 }
  208.             }
  209.         }
  210.  
  211.  
  212.         mod = 0;
  213.         while (x_Variations > 0 || y_Variations > 0 || z_Variations > 0)
  214.         {
  215.             if (!(mod % 3) && x_Variations > 0)
  216.             {
  217.                 if (x_VariationsTourDone == x_dim)
  218.                     x_VariationsTourDone -= x_dim;
  219.  
  220.                 cubicString_matrix_rightLateralRotation(stringMatrix, x_dim, 1, x_VariationsTourDone);
  221.  
  222.                 x_Variations--;
  223.                 mod++;
  224.                 x_VariationsTourDone++;
  225.             }
  226.             else if ((mod % 3) == 1 && y_Variations > 0)
  227.             {
  228.                 if (y_VariationsTourDone == x_dim)
  229.                     y_VariationsTourDone -= x_dim;
  230.  
  231.                 cubicString_matrix_frontVerticalRotation(stringMatrix, x_dim, 1, y_VariationsTourDone);
  232.  
  233.                 y_Variations--;
  234.                 mod++;
  235.                 y_VariationsTourDone++;
  236.             }
  237.             else if ((mod % 3) == 2 && z_Variations > 0)
  238.             {
  239.                 if (z_VariationsTourDone == x_dim)
  240.                     z_VariationsTourDone -= x_dim;
  241.  
  242.                 cubicString_matrix_leftVerticalRotation(stringMatrix, x_dim, 1, z_VariationsTourDone);
  243.  
  244.                 z_Variations--;
  245.                 mod++;
  246.                 z_VariationsTourDone++;
  247.             }
  248.             else
  249.                 mod++;
  250.         }
  251.  
  252.         char *stringToEncrypt = NULL;
  253.         stringToEncrypt = malloc(sizeof(char*)* 2 + sizeof(char*)*z_dim*y_dim*x_dim);
  254.         if (stringToEncrypt == NULL)
  255.         {
  256.             centerText("Pas assez de RAM pour allouer stringToEncrypt", CONS_L, 15, 0);
  257.  
  258.             Sleep(10000);
  259.             exit(1);
  260.         }
  261.         else
  262.         {
  263.             for (x = 0; x < 2 + z_dim*y_dim*x_dim; x++)
  264.                 stringToEncrypt[x] = '\0';
  265.  
  266.             w = 0;
  267.             for (z = 0; z < z_dim; z++)
  268.             {
  269.                 for (y = 0; y < y_dim; y++)
  270.                 {
  271.                     for (x = 0; x < x_dim; x++)
  272.                     {
  273.                         if (strcmp(stringMatrix[z][y][x], "KK") == NULL)
  274.                             stringToEncrypt[w] = '~';
  275.                         else
  276.                             stringToEncrypt[w] = stringMatrix[z][y][x][0];
  277.  
  278.                         w++;
  279.                     }
  280.                 }
  281.             }
  282.         }
  283.  
  284.         free(stringDecrypted);
  285.  
  286.         for (z = 0; z < z_dim; z++)
  287.             for (y = 0; y < y_dim; y++)
  288.                 for (x = 0; x < x_dim; x++)
  289.                     free(stringMatrix[z][y][x]);
  290.  
  291.         free(stringMatrix);
  292.  
  293.         return (stringToEncrypt);
  294.     }
  295.     else
  296.     {
  297.         while (z_dim*y_dim*x_dim < stringLength)
  298.         {
  299.             if (!(mod_3 % 3))
  300.                 x_dim++;
  301.             else if (mod_3 % 3 == 1)
  302.                 y_dim++;
  303.             else
  304.                 z_dim++;
  305.  
  306.             mod_3++;
  307.         }
  308.         if ((x_dim > y_dim&&x_dim >= z_dim) || (x_dim >= y_dim&&x_dim > z_dim))
  309.         {
  310.             y_dim = x_dim;
  311.             z_dim = x_dim;
  312.         }
  313.         else if ((y_dim > x_dim&&y_dim >= z_dim) || (y_dim >= x_dim&&y_dim > z_dim))
  314.         {
  315.             x_dim = y_dim;
  316.             z_dim = y_dim;
  317.         }
  318.         else if ((z_dim > x_dim&&z_dim >= y_dim) || (z_dim >= x_dim&&z_dim > y_dim))
  319.         {
  320.             x_dim = z_dim;
  321.             y_dim = z_dim;
  322.         }
  323.  
  324.         char ****stringMatrix = NULL;
  325.         stringMatrix = malloc(sizeof(char****)* z_dim);
  326.  
  327.         for (y = 0; y < y_dim; y++)
  328.             stringMatrix[y] = malloc(sizeof(char***)*y_dim);
  329.  
  330.         for (y = 0; y < y_dim; y++)
  331.         for (x = 0; x < x_dim; x++)
  332.             stringMatrix[y][x] = malloc(sizeof(char**)*x_dim);
  333.  
  334.         for (z = 0; z < z_dim; z++)
  335.         for (y = 0; y < y_dim; y++)
  336.         for (x = 0; x < x_dim; x++)
  337.             stringMatrix[z][y][x] = malloc((sizeof(char*)) * 3);
  338.  
  339.         for (z = 0; z < z_dim; z++)
  340.         {
  341.             for (y = 0; y < y_dim; y++)
  342.             {
  343.                 for (x = 0; x < x_dim; x++)
  344.                 {
  345.                     stringMatrix[z][y][x][0] = '\0';
  346.                     stringMatrix[z][y][x][1] = '\0';
  347.                     stringMatrix[z][y][x][2] = '\0';
  348.                 }
  349.             }
  350.         }
  351.  
  352.         w = 0;
  353.         for (z = 0; z < z_dim; z++)
  354.         {
  355.             for (y = 0; y < y_dim; y++)
  356.             {
  357.                 for (x = 0; x < x_dim; x++)
  358.                 {
  359.                     if (string[w] == '\0')
  360.                         sprintf(stringMatrix[z][y][x], "KK");
  361.                     else
  362.                     {
  363.                         sprintf(string_temp, "%c", string[w]);;
  364.                         sprintf(stringMatrix[z][y][x], "%s", string_temp);
  365.                     }
  366.  
  367.                     w++;
  368.                 }
  369.             }
  370.         }
  371.  
  372.         int *actionsSequence = NULL;
  373.         actionsSequence = malloc(sizeof(int*)*(x_Variations + y_Variations + z_Variations) * 2);
  374.  
  375.         if (actionsSequence == NULL)
  376.         {
  377.             printf("Pas assez de RAM pour allouer actionsSequence[%d]", x_Variations + y_Variations + z_Variations);
  378.  
  379.             Sleep(10000);
  380.             exit(1);
  381.         }
  382.         else
  383.         {
  384.             mod = 0;
  385.             w = 0;
  386.             while (x_Variations > 0 || y_Variations > 0 || z_Variations > 0)
  387.             {
  388.                 if (!(mod % 3) && x_Variations > 0)
  389.                 {
  390.                     if (x_VariationsTourDone == x_dim)
  391.                         x_VariationsTourDone -= x_dim;
  392.  
  393.                     actionsSequence[w] = 0;
  394.                     actionsSequence[w + 1] = x_VariationsTourDone;
  395.  
  396.                     x_Variations--;
  397.                     mod++;
  398.                     x_VariationsTourDone++;
  399.  
  400.                     w++;
  401.                     w++;
  402.                 }
  403.                 else if ((mod % 3) == 1 && y_Variations > 0)
  404.                 {
  405.                     if (y_VariationsTourDone == x_dim)
  406.                         y_VariationsTourDone -= x_dim;
  407.  
  408.                     actionsSequence[w] = 1;
  409.                     actionsSequence[w + 1] = y_VariationsTourDone;
  410.  
  411.                     y_Variations--;
  412.                     mod++;
  413.                     y_VariationsTourDone++;
  414.  
  415.                     w++;
  416.                     w++;
  417.                 }
  418.                 else if ((mod % 3) == 2 && z_Variations > 0)
  419.                 {
  420.                     if (z_VariationsTourDone == x_dim)
  421.                         z_VariationsTourDone -= x_dim;
  422.  
  423.                     actionsSequence[w] = 2;
  424.                     actionsSequence[w + 1] = z_VariationsTourDone;
  425.  
  426.                     z_Variations--;
  427.                     mod++;
  428.                     z_VariationsTourDone++;
  429.  
  430.                     w++;
  431.                     w++;
  432.                 }
  433.                 else
  434.                     mod++;
  435.             }
  436.         }
  437.         x_Variations = x_VariationsBackup;
  438.         y_Variations = y_VariationsBackup;
  439.         z_Variations = z_VariationsBackup;
  440.  
  441.         for (x = (x_Variations + y_Variations + z_Variations) * 2 - 1; x > -1; x -= 2)
  442.         {
  443.             switch (actionsSequence[x - 1])
  444.             {
  445.             case 0:
  446.                 cubicString_matrix_leftLateralRotation(stringMatrix, x_dim, 1, actionsSequence[x]);
  447.                 break;
  448.             case 1:
  449.                 cubicString_matrix_backVerticalRotation(stringMatrix, x_dim, 1, actionsSequence[x]);
  450.                 break;
  451.             case 2:
  452.                 cubicString_matrix_rightVerticalRotation(stringMatrix, x_dim, 1, actionsSequence[x]);
  453.                 break;
  454.             default:
  455.                 printf("Erreurrrrrr !!!!!!!!!!!!!!!!!!!!");
  456.                 break;
  457.             }
  458.         }
  459.  
  460.         for (x = 0; x < stringLength / 8; x++)
  461.             stringDecrypted[x] = '\0';
  462.  
  463.         for (z = 0; z < z_dim; z++)
  464.         for (y = 0; y < y_dim; y++)
  465.         for (x = 0; x < x_dim; x++)
  466.             strcat(stringDecrypted, stringMatrix[z][y][x]);
  467.  
  468.         char *ptr = NULL;
  469.         ptr = strchr(stringDecrypted, '~');
  470.         if (ptr != NULL)
  471.             *ptr = '\0';
  472.  
  473.         for (z = 0; z < z_dim; z++)
  474.             for (y = 0; y < y_dim; y++)
  475.                 for (x = 0; x < x_dim; x++)
  476.                     free(stringMatrix[z][y][x]);
  477.         free(stringMatrix);
  478.  
  479.         free(actionsSequence);
  480.  
  481.         return (stringDecrypted);
  482.     }
  483. }
  484.  
  485. void cubicString_matrix_rightLateralRotation(char *****matrix, double matrix_size, int numbOf_tour, int layerTo_switch)
  486. {
  487.     int matrix_sizeOrig = matrix_size;
  488.     int z = 0;
  489.     int x = 0;
  490.  
  491.     int placeOf_alpha = 1;
  492.     _Bool verif = 0;
  493.  
  494.     int externRotation = 0;
  495.     int tour = 0;
  496.  
  497.     char temp[3] = { 0 };
  498.     char temp2[3] = { 0 };
  499.  
  500.     if (!((int)matrix_size % 2))
  501.     {
  502.         for (tour = 0; tour < numbOf_tour; tour++)
  503.         {
  504.             matrix_size = matrix_sizeOrig;
  505.             placeOf_alpha = 1;
  506.  
  507.             while (matrix_size >= 2)
  508.             {
  509.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  510.                 {
  511.                     for (x = placeOf_alpha; x <= matrix_sizeOrig - placeOf_alpha; x++)
  512.                     {
  513.                         if (x == placeOf_alpha)
  514.                         {
  515.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  516.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], matrix[placeOf_alpha - 1][layerTo_switch][x - 1]);
  517.  
  518.                             verif = 0;
  519.                         }
  520.                         else if (!verif)
  521.                         {
  522.                             sprintf(temp2, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  523.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp);
  524.  
  525.                             verif = 1;
  526.                         }
  527.                         else
  528.                         {
  529.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  530.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp2);
  531.  
  532.                             verif = 0;
  533.                         }
  534.                     }
  535.  
  536.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  537.                     {
  538.                         if (!verif)
  539.                         {
  540.                             sprintf(temp2, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  541.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp);
  542.  
  543.                             verif = 1;
  544.                         }
  545.                         else
  546.                         {
  547.                             sprintf(temp, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  548.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp2);
  549.  
  550.                             verif = 0;
  551.                         }
  552.                     }
  553.  
  554.                     for (x = matrix_sizeOrig - (placeOf_alpha + 1); x >= placeOf_alpha - 1; x--)
  555.                     {
  556.                         if (!verif)
  557.                         {
  558.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  559.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp);
  560.  
  561.                             verif = 1;
  562.                         }
  563.                         else
  564.                         {
  565.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  566.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp2);
  567.  
  568.                             verif = 0;
  569.                         }
  570.                     }
  571.  
  572.                     for (z = matrix_sizeOrig - (placeOf_alpha + 1); z >= placeOf_alpha - 1; z--)
  573.                     {
  574.                         if (!verif)
  575.                         {
  576.                             sprintf(temp2, matrix[z][layerTo_switch][placeOf_alpha - 1]);
  577.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp);
  578.  
  579.                             verif = 1;
  580.                         }
  581.                         else
  582.                         {
  583.                             sprintf(temp, matrix[z][layerTo_switch][placeOf_alpha - 1]);
  584.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp2);
  585.  
  586.                             verif = 0;
  587.                         }
  588.                     }
  589.                 }
  590.                
  591.                 matrix_size -= 2;
  592.                 placeOf_alpha++;
  593.             }
  594.         }
  595.     }
  596.     else
  597.     {
  598.         for (tour = 0; tour < numbOf_tour; tour++)
  599.         {
  600.             matrix_size = matrix_sizeOrig;
  601.             placeOf_alpha = 1;
  602.  
  603.             while (matrix_size >= 2)
  604.             {
  605.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  606.                 {
  607.                     for (x = placeOf_alpha; x <= matrix_sizeOrig - placeOf_alpha; x++)
  608.                     {
  609.                         if (x == placeOf_alpha)
  610.                         {
  611.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  612.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], matrix[placeOf_alpha - 1][layerTo_switch][x - 1]);
  613.  
  614.                             verif = 0;
  615.                         }
  616.                         else if (!verif)
  617.                         {
  618.                             sprintf(temp2, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  619.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp);
  620.  
  621.                             verif = 1;
  622.                         }
  623.                         else
  624.                         {
  625.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  626.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp2);
  627.  
  628.                             verif = 0;
  629.                         }
  630.                     }
  631.  
  632.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  633.                     {
  634.                         if (!verif)
  635.                         {
  636.                             sprintf(temp2, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  637.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp);
  638.  
  639.                             verif = 1;
  640.                         }
  641.                         else
  642.                         {
  643.                             sprintf(temp, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  644.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp2);
  645.  
  646.                             verif = 0;
  647.                         }
  648.                     }
  649.  
  650.                     for (x = matrix_sizeOrig - (placeOf_alpha + 1); x >= placeOf_alpha - 1; x--)
  651.                     {
  652.                         if (!verif)
  653.                         {
  654.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  655.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp);
  656.  
  657.                             verif = 1;
  658.                         }
  659.                         else
  660.                         {
  661.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  662.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp2);
  663.  
  664.                             verif = 0;
  665.                         }
  666.                     }
  667.  
  668.                     for (z = matrix_sizeOrig - (placeOf_alpha + 1); z >= placeOf_alpha - 1; z--)
  669.                     {
  670.                         if (!verif)
  671.                         {
  672.                             sprintf(temp2, matrix[z][layerTo_switch][placeOf_alpha - 1]);
  673.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp);
  674.  
  675.                             verif = 1;
  676.                         }
  677.                         else
  678.                         {
  679.                             sprintf(temp, matrix[z][layerTo_switch][placeOf_alpha - 1]);
  680.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp2);
  681.  
  682.                             verif = 0;
  683.                         }
  684.                     }
  685.                 }
  686.                
  687.                 matrix_size -= 2;
  688.                 placeOf_alpha++;
  689.             }
  690.         }
  691.     }
  692. }
  693.  
  694. void cubicString_matrix_frontVerticalRotation(char *****matrix, double matrix_size, int numbOf_tour, int faceTo_switch)
  695. {
  696.     int matrix_sizeOrig = matrix_size;
  697.     int x = 0;
  698.     int y = 0;
  699.  
  700.     int placeOf_alpha = 1;
  701.     _Bool verif = 0;
  702.  
  703.     int externRotation = 0;
  704.     int tour = 0;
  705.  
  706.     char temp[3] = { 0 };
  707.     char temp2[3] = { 0 };
  708.  
  709.     if (!((int)matrix_size % 2))
  710.     {
  711.         for (tour = 0; tour < numbOf_tour; tour++)
  712.         {
  713.             matrix_size = matrix_sizeOrig;
  714.             placeOf_alpha = 1;
  715.  
  716.             while (matrix_size >= 2)
  717.             {
  718.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  719.                 {
  720.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= placeOf_alpha - 1; y--)
  721.                     {
  722.                         if (y == matrix_sizeOrig - (placeOf_alpha + 1))
  723.                         {
  724.                             sprintf(temp, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  725.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], matrix[faceTo_switch][y + 1][matrix_sizeOrig - placeOf_alpha]);
  726.  
  727.                             verif = 0;
  728.                         }
  729.                         else if (!verif)
  730.                         {
  731.                             sprintf(temp2, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  732.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp);
  733.  
  734.                             verif = 1;
  735.                         }
  736.                         else
  737.                         {
  738.                             sprintf(temp, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  739.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp2);
  740.  
  741.                             verif = 0;
  742.                         }
  743.                     }
  744.  
  745.                     for (x = matrix_sizeOrig - (placeOf_alpha + 1); x >= placeOf_alpha - 1; x--)
  746.                     {
  747.                         if (!verif)
  748.                         {
  749.                             sprintf(temp2, matrix[faceTo_switch][placeOf_alpha - 1][x]);
  750.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp);
  751.  
  752.                             verif = 1;
  753.                         }
  754.                         else
  755.                         {
  756.                             sprintf(temp, matrix[faceTo_switch][placeOf_alpha - 1][x]);
  757.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp2);
  758.  
  759.                             verif = 0;
  760.                         }
  761.                     }
  762.  
  763.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  764.                     {
  765.                         if (!verif)
  766.                         {
  767.                             sprintf(temp2, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  768.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp);
  769.  
  770.                             verif = 1;
  771.                         }
  772.                         else
  773.                         {
  774.                             sprintf(temp, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  775.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp2);
  776.  
  777.                             verif = 0;
  778.                         }
  779.                     }
  780.  
  781.                     for (x = placeOf_alpha; x <= matrix_sizeOrig - placeOf_alpha; x++)
  782.                     {
  783.                         if (!verif)
  784.                         {
  785.                             sprintf(temp2, matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x]);
  786.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp);
  787.  
  788.                             verif = 1;
  789.                         }
  790.                         else
  791.                         {
  792.                             sprintf(temp, matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x]);
  793.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp2);
  794.  
  795.                             verif = 0;
  796.                         }
  797.                     }
  798.                 }
  799.  
  800.                 matrix_size -= 2;
  801.                 placeOf_alpha++;
  802.             }
  803.         }
  804.     }
  805.     else
  806.     {
  807.         for (tour = 0; tour < numbOf_tour; tour++)
  808.         {
  809.             matrix_size = matrix_sizeOrig;
  810.             placeOf_alpha = 1;
  811.  
  812.             while (matrix_size >= 2)
  813.             {
  814.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  815.                 {
  816.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= placeOf_alpha - 1; y--)
  817.                     {
  818.                         if (y == matrix_sizeOrig - (placeOf_alpha + 1))
  819.                         {
  820.                             sprintf(temp, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  821.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], matrix[faceTo_switch][y + 1][matrix_sizeOrig - placeOf_alpha]);
  822.  
  823.                             verif = 0;
  824.                         }
  825.                         else if (!verif)
  826.                         {
  827.                             sprintf(temp2, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  828.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp);
  829.  
  830.                             verif = 1;
  831.                         }
  832.                         else
  833.                         {
  834.                             sprintf(temp, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  835.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp2);
  836.  
  837.                             verif = 0;
  838.                         }
  839.                     }
  840.  
  841.                     for (x = matrix_sizeOrig-(placeOf_alpha+1); x >= placeOf_alpha-1; x--)
  842.                     {
  843.                         if (!verif)
  844.                         {
  845.                             sprintf(temp2, matrix[faceTo_switch][placeOf_alpha-1][x]);
  846.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp);
  847.  
  848.                             verif = 1;
  849.                         }
  850.                         else
  851.                         {
  852.                             sprintf(temp, matrix[faceTo_switch][placeOf_alpha - 1][x]);
  853.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp2);
  854.  
  855.                             verif = 0;
  856.                         }
  857.                     }
  858.  
  859.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  860.                     {
  861.                         if (!verif)
  862.                         {
  863.                             sprintf(temp2, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  864.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp);
  865.  
  866.                             verif = 1;
  867.                         }
  868.                         else
  869.                         {
  870.                             sprintf(temp, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  871.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp2);
  872.  
  873.                             verif = 0;
  874.                         }
  875.                     }
  876.  
  877.                     for (x = placeOf_alpha; x <= matrix_sizeOrig-placeOf_alpha; x++)
  878.                     {
  879.                         if (!verif)
  880.                         {
  881.                             sprintf(temp2, matrix[faceTo_switch][matrix_sizeOrig-placeOf_alpha][x]);
  882.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp);
  883.  
  884.                             verif = 1;
  885.                         }
  886.                         else
  887.                         {
  888.                             sprintf(temp, matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x]);
  889.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp2);
  890.  
  891.                             verif = 0;
  892.                         }
  893.                     }
  894.                 }
  895.  
  896.                 matrix_size -= 2;
  897.                 placeOf_alpha++;
  898.             }
  899.         }
  900.     }
  901. }
  902.  
  903. void cubicString_matrix_leftVerticalRotation(char *****matrix, double matrix_size, int numbOf_tour, int faceTo_switch)
  904. {
  905.     int matrix_sizeOrig = matrix_size;
  906.     int y = 0;
  907.     int z = 0;
  908.  
  909.     int placeOf_alpha = 1;
  910.     _Bool verif = 0;
  911.  
  912.     int externRotation = 0;
  913.     int tour = 0;
  914.  
  915.     char temp[3] = { 0 };
  916.     char temp2[3] = { 0 };
  917.  
  918.     if (!((int)matrix_size % 2))
  919.     {
  920.         for (tour = 0; tour < numbOf_tour; tour++)
  921.         {
  922.             matrix_size = matrix_sizeOrig;
  923.             placeOf_alpha = 1;
  924.  
  925.             while (matrix_size >= 2)
  926.             {
  927.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  928.                 {
  929.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  930.                     {
  931.                         if (y == placeOf_alpha)
  932.                         {
  933.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  934.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], matrix[placeOf_alpha - 1][y - 1][faceTo_switch]);
  935.  
  936.                             verif = 0;
  937.                         }
  938.                         else if (!verif)
  939.                         {
  940.                             sprintf(temp2, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  941.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp);
  942.  
  943.                             verif = 1;
  944.                         }
  945.                         else
  946.                         {
  947.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  948.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp2);
  949.  
  950.                             verif = 0;
  951.                         }
  952.                     }
  953.  
  954.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  955.                     {
  956.                         if (!verif)
  957.                         {
  958.                             sprintf(temp2, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  959.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp);
  960.  
  961.                             verif = 1;
  962.                         }
  963.                         else
  964.                         {
  965.                             sprintf(temp, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  966.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp2);
  967.  
  968.                             verif = 0;
  969.                         }
  970.                     }
  971.  
  972.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= placeOf_alpha - 1; y--)
  973.                     {
  974.                         if (!verif)
  975.                         {
  976.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  977.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp);
  978.  
  979.                             verif = 1;
  980.                         }
  981.                         else
  982.                         {
  983.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  984.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp2);
  985.  
  986.                             verif = 0;
  987.                         }
  988.                     }
  989.  
  990.                     for (z = matrix_sizeOrig - (placeOf_alpha + 1); z >= placeOf_alpha - 1; z--)
  991.                     {
  992.                         if (!verif)
  993.                         {
  994.                             sprintf(temp2, matrix[z][placeOf_alpha - 1][faceTo_switch]);
  995.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp);
  996.  
  997.                             verif = 1;
  998.                         }
  999.                         else
  1000.                         {
  1001.                             sprintf(temp, matrix[z][placeOf_alpha - 1][faceTo_switch]);
  1002.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp2);
  1003.  
  1004.                             verif = 0;
  1005.                         }
  1006.                     }
  1007.                 }
  1008.  
  1009.                 matrix_size -= 2;
  1010.                 placeOf_alpha++;
  1011.             }
  1012.         }
  1013.     }
  1014.     else
  1015.     {
  1016.         for (tour = 0; tour < numbOf_tour; tour++)
  1017.         {
  1018.             matrix_size = matrix_sizeOrig;
  1019.             placeOf_alpha = 1;
  1020.  
  1021.             while (matrix_size >= 2)
  1022.             {
  1023.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  1024.                 {
  1025.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  1026.                     {
  1027.                         if (y == placeOf_alpha)
  1028.                         {
  1029.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1030.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], matrix[placeOf_alpha - 1][y - 1][faceTo_switch]);
  1031.  
  1032.                             verif = 0;
  1033.                         }
  1034.                         else if (!verif)
  1035.                         {
  1036.                             sprintf(temp2, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1037.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp);
  1038.  
  1039.                             verif = 1;
  1040.                         }
  1041.                         else
  1042.                         {
  1043.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1044.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp2);
  1045.  
  1046.                             verif = 0;
  1047.                         }
  1048.                     }
  1049.  
  1050.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  1051.                     {
  1052.                         if (!verif)
  1053.                         {
  1054.                             sprintf(temp2, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  1055.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp);
  1056.  
  1057.                             verif = 1;
  1058.                         }
  1059.                         else
  1060.                         {
  1061.                             sprintf(temp, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  1062.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp2);
  1063.  
  1064.                             verif = 0;
  1065.                         }
  1066.                     }
  1067.  
  1068.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= placeOf_alpha - 1; y--)
  1069.                     {
  1070.                         if (!verif)
  1071.                         {
  1072.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  1073.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp);
  1074.  
  1075.                             verif = 1;
  1076.                         }
  1077.                         else
  1078.                         {
  1079.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  1080.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp2);
  1081.  
  1082.                             verif = 0;
  1083.                         }
  1084.                     }
  1085.  
  1086.                     for (z = matrix_sizeOrig-(placeOf_alpha+1); z >= placeOf_alpha - 1; z--)
  1087.                     {
  1088.                         if (!verif)
  1089.                         {
  1090.                             sprintf(temp2, matrix[z][placeOf_alpha-1][faceTo_switch]);
  1091.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp);
  1092.  
  1093.                             verif = 1;
  1094.                         }
  1095.                         else
  1096.                         {
  1097.                             sprintf(temp, matrix[z][placeOf_alpha - 1][faceTo_switch]);
  1098.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp2);
  1099.  
  1100.                             verif = 0;
  1101.                         }
  1102.                     }
  1103.                 }
  1104.  
  1105.                 matrix_size -= 2;
  1106.                 placeOf_alpha++;
  1107.             }
  1108.         }
  1109.     }
  1110. }
  1111.  
  1112. void cubicString_matrix_leftLateralRotation(char *****matrix, double matrix_size, int numbOf_tour, int layerTo_switch)
  1113. {
  1114.     int matrix_sizeOrig = matrix_size;
  1115.     int z = 0;
  1116.     int x = 0;
  1117.  
  1118.     int placeOf_alpha = 1;
  1119.     _Bool verif = 0;
  1120.  
  1121.     int externRotation = 0;
  1122.     int tour = 0;
  1123.  
  1124.     char temp[3] = { 0 };
  1125.     char temp2[3] = { 0 };
  1126.  
  1127.     if (!((int)matrix_size % 2))
  1128.     {
  1129.         for (tour = 0; tour < numbOf_tour; tour++)
  1130.         {
  1131.             matrix_size = matrix_sizeOrig;
  1132.             placeOf_alpha = 1;
  1133.  
  1134.             while (matrix_size >= 2)
  1135.             {
  1136.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  1137.                 {
  1138.                     for (x = matrix_sizeOrig - (placeOf_alpha+1);x >= placeOf_alpha-1; x--)
  1139.                     {
  1140.                         if (x == matrix_sizeOrig - (placeOf_alpha + 1))
  1141.                         {
  1142.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  1143.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], matrix[placeOf_alpha - 1][layerTo_switch][x + 1]);
  1144.  
  1145.                             verif = 0;
  1146.                         }
  1147.                         else if (!verif)
  1148.                         {
  1149.                             sprintf(temp2, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  1150.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp);
  1151.  
  1152.                             verif = 1;
  1153.                         }
  1154.                         else
  1155.                         {
  1156.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  1157.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp2);
  1158.  
  1159.                             verif = 0;
  1160.                         }
  1161.                     }
  1162.  
  1163.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  1164.                     {
  1165.                         if (!verif)
  1166.                         {
  1167.                             sprintf(temp2, matrix[z][layerTo_switch][placeOf_alpha-1]);
  1168.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp);
  1169.  
  1170.                             verif = 1;
  1171.                         }
  1172.                         else
  1173.                         {
  1174.                             sprintf(temp, matrix[z][layerTo_switch][placeOf_alpha - 1]);
  1175.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp2);
  1176.  
  1177.                             verif = 0;
  1178.                         }
  1179.                     }
  1180.  
  1181.                     for (x = placeOf_alpha; x <= matrix_sizeOrig-placeOf_alpha; x++)
  1182.                     {
  1183.                         if (!verif)
  1184.                         {
  1185.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  1186.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp);
  1187.  
  1188.                             verif = 1;
  1189.                         }
  1190.                         else
  1191.                         {
  1192.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  1193.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp2);
  1194.  
  1195.                             verif = 0;
  1196.                         }
  1197.                     }
  1198.  
  1199.                     for (z = matrix_sizeOrig - (placeOf_alpha + 1); z >= placeOf_alpha - 1; z--)
  1200.                     {
  1201.                         if (!verif)
  1202.                         {
  1203.                             sprintf(temp2, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  1204.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp);
  1205.  
  1206.                             verif = 1;
  1207.                         }
  1208.                         else
  1209.                         {
  1210.                             sprintf(temp, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  1211.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp2);
  1212.  
  1213.                             verif = 0;
  1214.                         }
  1215.                     }
  1216.                 }
  1217.                
  1218.                 matrix_size -= 2;
  1219.                 placeOf_alpha++;
  1220.             }
  1221.         }
  1222.     }
  1223.     else
  1224.     {
  1225.         for (tour = 0; tour < numbOf_tour; tour++)
  1226.         {
  1227.             matrix_size = matrix_sizeOrig;
  1228.             placeOf_alpha = 1;
  1229.  
  1230.             while (matrix_size >= 2)
  1231.             {
  1232.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  1233.                 {
  1234.                     for (x = matrix_sizeOrig - (placeOf_alpha + 1); x >= placeOf_alpha - 1; x--)
  1235.                     {
  1236.                         if (x == matrix_sizeOrig - (placeOf_alpha + 1))
  1237.                         {
  1238.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  1239.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], matrix[placeOf_alpha - 1][layerTo_switch][x + 1]);
  1240.  
  1241.                             verif = 0;
  1242.                         }
  1243.                         else if (!verif)
  1244.                         {
  1245.                             sprintf(temp2, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  1246.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp);
  1247.  
  1248.                             verif = 1;
  1249.                         }
  1250.                         else
  1251.                         {
  1252.                             sprintf(temp, matrix[placeOf_alpha - 1][layerTo_switch][x]);
  1253.                             sprintf(matrix[placeOf_alpha - 1][layerTo_switch][x], temp2);
  1254.  
  1255.                             verif = 0;
  1256.                         }
  1257.                     }
  1258.  
  1259.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  1260.                     {
  1261.                         if (!verif)
  1262.                         {
  1263.                             sprintf(temp2, matrix[z][layerTo_switch][placeOf_alpha - 1]);
  1264.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp);
  1265.  
  1266.                             verif = 1;
  1267.                         }
  1268.                         else
  1269.                         {
  1270.                             sprintf(temp, matrix[z][layerTo_switch][placeOf_alpha - 1]);
  1271.                             sprintf(matrix[z][layerTo_switch][placeOf_alpha - 1], temp2);
  1272.  
  1273.                             verif = 0;
  1274.                         }
  1275.                     }
  1276.  
  1277.                     for (x = placeOf_alpha; x <= matrix_sizeOrig - placeOf_alpha; x++)
  1278.                     {
  1279.                         if (!verif)
  1280.                         {
  1281.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  1282.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp);
  1283.  
  1284.                             verif = 1;
  1285.                         }
  1286.                         else
  1287.                         {
  1288.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x]);
  1289.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][layerTo_switch][x], temp2);
  1290.  
  1291.                             verif = 0;
  1292.                         }
  1293.                     }
  1294.  
  1295.                     for (z = matrix_sizeOrig - (placeOf_alpha + 1); z >= placeOf_alpha - 1; z--)
  1296.                     {
  1297.                         if (!verif)
  1298.                         {
  1299.                             sprintf(temp2, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  1300.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp);
  1301.  
  1302.                             verif = 1;
  1303.                         }
  1304.                         else
  1305.                         {
  1306.                             sprintf(temp, matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha]);
  1307.                             sprintf(matrix[z][layerTo_switch][matrix_sizeOrig - placeOf_alpha], temp2);
  1308.  
  1309.                             verif = 0;
  1310.                         }
  1311.                     }
  1312.                 }
  1313.                
  1314.                 matrix_size -= 2;
  1315.                 placeOf_alpha++;
  1316.             }
  1317.         }
  1318.     }
  1319. }
  1320.  
  1321. void cubicString_matrix_backVerticalRotation(char *****matrix, double matrix_size, int numbOf_tour, int faceTo_switch)
  1322. {
  1323.     int matrix_sizeOrig = matrix_size;
  1324.     int x = 0;
  1325.     int y = 0;
  1326.  
  1327.     int placeOf_alpha = 1;
  1328.     _Bool verif = 0;
  1329.  
  1330.     int externRotation = 0;
  1331.     int tour = 0;
  1332.  
  1333.     char temp[3] = { 0 };
  1334.     char temp2[3] = { 0 };
  1335.  
  1336.     if (!((int)matrix_size % 2))
  1337.     {
  1338.         for (tour = 0; tour < numbOf_tour; tour++)
  1339.         {
  1340.             matrix_size = matrix_sizeOrig;
  1341.             placeOf_alpha = 1;
  1342.  
  1343.             while (matrix_size >= 2)
  1344.             {
  1345.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  1346.                 {
  1347.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= placeOf_alpha - 1; y--)
  1348.                     {
  1349.                         if (y == matrix_sizeOrig - (placeOf_alpha + 1))
  1350.                         {
  1351.                             sprintf(temp, matrix[faceTo_switch][y][placeOf_alpha-1]);
  1352.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], matrix[faceTo_switch][y+1][placeOf_alpha - 1]);
  1353.  
  1354.                             verif = 0;
  1355.                         }
  1356.                         else if (!verif)
  1357.                         {
  1358.                             sprintf(temp2, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  1359.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp);
  1360.  
  1361.                             verif = 1;
  1362.                         }
  1363.                         else
  1364.                         {
  1365.                             sprintf(temp, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  1366.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp2);
  1367.  
  1368.                             verif = 0;
  1369.                         }
  1370.                     }
  1371.  
  1372.                     for (x = placeOf_alpha; x <= matrix_sizeOrig-placeOf_alpha; x++)
  1373.                     {
  1374.                         if (!verif)
  1375.                         {
  1376.                             sprintf(temp2, matrix[faceTo_switch][placeOf_alpha - 1][x]);
  1377.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp);
  1378.  
  1379.                             verif = 1;
  1380.                         }
  1381.                         else
  1382.                         {
  1383.                             sprintf(temp, matrix[faceTo_switch][placeOf_alpha - 1][x]);
  1384.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp2);
  1385.  
  1386.                             verif = 0;
  1387.                         }
  1388.                     }
  1389.  
  1390.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  1391.                     {
  1392.                         if (!verif)
  1393.                         {
  1394.                             sprintf(temp2, matrix[faceTo_switch][y][matrix_sizeOrig-placeOf_alpha]);
  1395.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp);
  1396.  
  1397.                             verif = 1;
  1398.                         }
  1399.                         else
  1400.                         {
  1401.                             sprintf(temp, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  1402.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp2);
  1403.  
  1404.                             verif = 0;
  1405.                         }
  1406.                     }
  1407.  
  1408.                     for (x = matrix_sizeOrig-(placeOf_alpha+1); x >= placeOf_alpha-1; x--)
  1409.                     {
  1410.                         if (!verif)
  1411.                         {
  1412.                             sprintf(temp2, matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x]);
  1413.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp);
  1414.  
  1415.                             verif = 1;
  1416.                         }
  1417.                         else
  1418.                         {
  1419.                             sprintf(temp, matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x]);
  1420.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp2);
  1421.  
  1422.                             verif = 0;
  1423.                         }
  1424.                     }
  1425.                 }
  1426.  
  1427.                 matrix_size -= 2;
  1428.                 placeOf_alpha++;
  1429.             }
  1430.         }
  1431.     }
  1432.     else
  1433.     {
  1434.         for (tour = 0; tour < numbOf_tour; tour++)
  1435.         {
  1436.             matrix_size = matrix_sizeOrig;
  1437.             placeOf_alpha = 1;
  1438.  
  1439.             while (matrix_size >= 2)
  1440.             {
  1441.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  1442.                 {
  1443.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= placeOf_alpha - 1; y--)
  1444.                     {
  1445.                         if (y == matrix_sizeOrig - (placeOf_alpha + 1))
  1446.                         {
  1447.                             sprintf(temp, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  1448.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], matrix[faceTo_switch][y+1][placeOf_alpha - 1]);
  1449.  
  1450.                             verif = 0;
  1451.                         }
  1452.                         else if (!verif)
  1453.                         {
  1454.                             sprintf(temp2, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  1455.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp);
  1456.  
  1457.                             verif = 1;
  1458.                         }
  1459.                         else
  1460.                         {
  1461.                             sprintf(temp, matrix[faceTo_switch][y][placeOf_alpha - 1]);
  1462.                             sprintf(matrix[faceTo_switch][y][placeOf_alpha - 1], temp2);
  1463.  
  1464.                             verif = 0;
  1465.                         }
  1466.                     }
  1467.  
  1468.                     for (x = placeOf_alpha; x <= matrix_sizeOrig - placeOf_alpha; x++)
  1469.                     {
  1470.                         if (!verif)
  1471.                         {
  1472.                             sprintf(temp2, matrix[faceTo_switch][placeOf_alpha - 1][x]);
  1473.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp);
  1474.  
  1475.                             verif = 1;
  1476.                         }
  1477.                         else
  1478.                         {
  1479.                             sprintf(temp, matrix[faceTo_switch][placeOf_alpha - 1][x]);
  1480.                             sprintf(matrix[faceTo_switch][placeOf_alpha - 1][x], temp2);
  1481.  
  1482.                             verif = 0;
  1483.                         }
  1484.                     }
  1485.  
  1486.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  1487.                     {
  1488.                         if (!verif)
  1489.                         {
  1490.                             sprintf(temp2, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  1491.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp);
  1492.  
  1493.                             verif = 1;
  1494.                         }
  1495.                         else
  1496.                         {
  1497.                             sprintf(temp, matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha]);
  1498.                             sprintf(matrix[faceTo_switch][y][matrix_sizeOrig - placeOf_alpha], temp2);
  1499.  
  1500.                             verif = 0;
  1501.                         }
  1502.                     }
  1503.  
  1504.                     for (x = matrix_sizeOrig - (placeOf_alpha + 1); x >= placeOf_alpha - 1; x--)
  1505.                     {
  1506.                         if (!verif)
  1507.                         {
  1508.                             sprintf(temp2, matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x]);
  1509.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp);
  1510.  
  1511.                             verif = 1;
  1512.                         }
  1513.                         else
  1514.                         {
  1515.                             sprintf(temp, matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x]);
  1516.                             sprintf(matrix[faceTo_switch][matrix_sizeOrig - placeOf_alpha][x], temp2);
  1517.  
  1518.                             verif = 0;
  1519.                         }
  1520.                     }
  1521.                 }
  1522.  
  1523.                 matrix_size -= 2;
  1524.                 placeOf_alpha++;
  1525.             }
  1526.         }
  1527.     }
  1528. }
  1529.  
  1530. void cubicString_matrix_rightVerticalRotation(char *****matrix, double matrix_size, int numbOf_tour, int faceTo_switch)
  1531. {
  1532.     int matrix_sizeOrig = matrix_size;
  1533.     int y = 0;
  1534.     int z = 0;
  1535.  
  1536.     int placeOf_alpha = 1;
  1537.     _Bool verif = 0;
  1538.  
  1539.     int externRotation = 0;
  1540.     int tour = 0;
  1541.  
  1542.     char temp[3] = { 0 };
  1543.     char temp2[3] = { 0 };
  1544.  
  1545.     if (!((int)matrix_size % 2))
  1546.     {
  1547.         for (tour = 0; tour < numbOf_tour; tour++)
  1548.         {
  1549.             matrix_size = matrix_sizeOrig;
  1550.             placeOf_alpha = 1;
  1551.  
  1552.             while (matrix_size >= 2)
  1553.             {
  1554.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  1555.                 {
  1556.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= (placeOf_alpha - 1); y--)
  1557.                     {
  1558.                         if (y == matrix_sizeOrig - (placeOf_alpha + 1))
  1559.                         {
  1560.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1561.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], matrix[placeOf_alpha - 1][y + 1][faceTo_switch]);
  1562.  
  1563.                             verif = 0;
  1564.                         }
  1565.                         else if (!verif)
  1566.                         {
  1567.                             sprintf(temp2, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1568.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp);
  1569.  
  1570.                             verif = 1;
  1571.                         }
  1572.                         else
  1573.                         {
  1574.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1575.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp2);
  1576.  
  1577.                             verif = 0;
  1578.                         }
  1579.                     }
  1580.  
  1581.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  1582.                     {
  1583.                         if (!verif)
  1584.                         {
  1585.                             sprintf(temp2, matrix[z][placeOf_alpha - 1][faceTo_switch]);
  1586.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp);
  1587.  
  1588.                             verif = 1;
  1589.                         }
  1590.                         else
  1591.                         {
  1592.                             sprintf(temp, matrix[z][placeOf_alpha - 1][faceTo_switch]);
  1593.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp2);
  1594.  
  1595.                             verif = 0;
  1596.                         }
  1597.                     }
  1598.  
  1599.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  1600.                     {
  1601.                         if (!verif)
  1602.                         {
  1603.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  1604.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp);
  1605.  
  1606.                             verif = 1;
  1607.                         }
  1608.                         else
  1609.                         {
  1610.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  1611.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp2);
  1612.  
  1613.                             verif = 0;
  1614.                         }
  1615.                     }
  1616.  
  1617.                     for (z = matrix_sizeOrig - (placeOf_alpha + 1); z >= placeOf_alpha - 1; z--)
  1618.                     {
  1619.                         if (!verif)
  1620.                         {
  1621.                             sprintf(temp2, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  1622.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp);
  1623.  
  1624.                             verif = 1;
  1625.                         }
  1626.                         else
  1627.                         {
  1628.                             sprintf(temp, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  1629.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp2);
  1630.  
  1631.                             verif = 0;
  1632.                         }
  1633.                     }
  1634.                 }
  1635.  
  1636.                 matrix_size -= 2;
  1637.                 placeOf_alpha++;
  1638.             }
  1639.         }
  1640.     }
  1641.     else
  1642.     {
  1643.         for (tour = 0; tour < numbOf_tour; tour++)
  1644.         {
  1645.             matrix_size = matrix_sizeOrig;
  1646.             placeOf_alpha = 1;
  1647.  
  1648.             while (matrix_size >= 2)
  1649.             {
  1650.                 for (externRotation = 0; externRotation < matrix_size - 1; externRotation++)
  1651.                 {
  1652.                     for (y = matrix_sizeOrig - (placeOf_alpha + 1); y >= (placeOf_alpha - 1); y--)
  1653.                     {
  1654.                         if (y == matrix_sizeOrig - (placeOf_alpha + 1))
  1655.                         {
  1656.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1657.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], matrix[placeOf_alpha - 1][y + 1][faceTo_switch]);
  1658.  
  1659.                             verif = 0;
  1660.                         }
  1661.                         else if (!verif)
  1662.                         {
  1663.                             sprintf(temp2, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1664.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp);
  1665.  
  1666.                             verif = 1;
  1667.                         }
  1668.                         else
  1669.                         {
  1670.                             sprintf(temp, matrix[placeOf_alpha - 1][y][faceTo_switch]);
  1671.                             sprintf(matrix[placeOf_alpha - 1][y][faceTo_switch], temp2);
  1672.  
  1673.                             verif = 0;
  1674.                         }
  1675.                     }
  1676.  
  1677.                     for (z = placeOf_alpha; z <= matrix_sizeOrig - placeOf_alpha; z++)
  1678.                     {
  1679.                         if (!verif)
  1680.                         {
  1681.                             sprintf(temp2, matrix[z][placeOf_alpha - 1][faceTo_switch]);
  1682.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp);
  1683.  
  1684.                             verif = 1;
  1685.                         }
  1686.                         else
  1687.                         {
  1688.                             sprintf(temp, matrix[z][placeOf_alpha - 1][faceTo_switch]);
  1689.                             sprintf(matrix[z][placeOf_alpha - 1][faceTo_switch], temp2);
  1690.  
  1691.                             verif = 0;
  1692.                         }
  1693.                     }
  1694.  
  1695.                     for (y = placeOf_alpha; y <= matrix_sizeOrig - placeOf_alpha; y++)
  1696.                     {
  1697.                         if (!verif)
  1698.                         {
  1699.                             sprintf(temp2, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  1700.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp);
  1701.  
  1702.                             verif = 1;
  1703.                         }
  1704.                         else
  1705.                         {
  1706.                             sprintf(temp, matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch]);
  1707.                             sprintf(matrix[matrix_sizeOrig - placeOf_alpha][y][faceTo_switch], temp2);
  1708.  
  1709.                             verif = 0;
  1710.                         }
  1711.                     }
  1712.  
  1713.                     for (z = matrix_sizeOrig - (placeOf_alpha + 1); z >= placeOf_alpha - 1; z--)
  1714.                     {
  1715.                         if (!verif)
  1716.                         {
  1717.                             sprintf(temp2, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  1718.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp);
  1719.  
  1720.                             verif = 1;
  1721.                         }
  1722.                         else
  1723.                         {
  1724.                             sprintf(temp, matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch]);
  1725.                             sprintf(matrix[z][matrix_sizeOrig - placeOf_alpha][faceTo_switch], temp2);
  1726.  
  1727.                             verif = 0;
  1728.                         }
  1729.                     }
  1730.                 }
  1731.  
  1732.                 matrix_size -= 2;
  1733.                 placeOf_alpha++;
  1734.             }
  1735.         }
  1736.     }
  1737. }
  1738.  
  1739. int identifyTriDiShaker_Size(char string[])
  1740. {
  1741.     int dim = 0;
  1742.  
  1743.     int stringLength = strlen(string);
  1744.  
  1745.     while (dim*dim*dim < stringLength)
  1746.         dim++;
  1747.  
  1748.     return (dim);
  1749. }
  1750.  
  1751. void string_random ( unsigned char string[], unsigned int rand_seed, int numbOf_tour, _Bool isReverse)
  1752. {
  1753.     int *randTab1 = NULL;
  1754.     int *randTab2 = NULL;
  1755.    
  1756.     int stringLength = strlen(string);
  1757.    
  1758.     randTab1 = malloc(sizeof(int)*numbOf_tour);
  1759.     if ( randTab1 == NULL )
  1760.     {
  1761.         printf("\n\n\n\n\nPas assez de RAM pour allouer \"randTab1\" dans string_random\n");
  1762.         printf("numbOf_tour: %d\nString ( %d ): %s", numbOf_tour, strlen(string), string);
  1763.        
  1764.         Sleep(10000);
  1765.         exit(0);
  1766.     }
  1767.    
  1768.     randTab2 = malloc(sizeof(int)*numbOf_tour);
  1769.     if ( randTab2 == NULL )
  1770.     {
  1771.         printf("\n\n\n\n\nPas assez de RAM pour allouer \"randTab2\" dans string_random");
  1772.         printf("numbOf_tour: %d\nString ( %d ): %s", numbOf_tour, strlen(string), string);
  1773.        
  1774.         Sleep(10000);
  1775.         exit(0);
  1776.     }
  1777.    
  1778.     int alea;
  1779.     int temp = 0;
  1780.    
  1781.     int x = 0;
  1782.    
  1783.     srand(rand_seed);
  1784.     if (stringLength > 1 )
  1785.     {
  1786.         for (x = 0;x < numbOf_tour; x++)
  1787.         {
  1788.             alea = rand() % stringLength;
  1789.             randTab1[x] = alea;
  1790.            
  1791.             alea = rand() % stringLength;
  1792.             randTab2[x] = alea;
  1793.         }
  1794.        
  1795.         if (!isReverse)
  1796.         {
  1797.             for (x = 0; x < numbOf_tour; x++)
  1798.             {
  1799.                 temp = string[randTab1[x]];
  1800.                 string[randTab1[x]] = string[randTab2[x]];
  1801.                 string[randTab2[x]] = temp;
  1802.             }
  1803.         }
  1804.         else
  1805.         {
  1806.             for (x = numbOf_tour - 1; x >= 0; x--)
  1807.             {
  1808.                 temp = string[randTab1[x]];
  1809.                 string[randTab1[x]] = string[randTab2[x]];
  1810.                 string[randTab2[x]] = temp;
  1811.             }
  1812.         }
  1813.     }
  1814.    
  1815.     free(randTab1);
  1816.     free(randTab2);
  1817. }
  1818.  
  1819. void string_rightRotation(char string[], int numbOf_tour)
  1820. {
  1821.     int stringLength = strlen(string);
  1822.     int x = 0;
  1823.     int y = 0;
  1824.  
  1825.     int permaTemp = 0;
  1826.    
  1827.     if (strlen(string) > 1)
  1828.     {
  1829.         for (x = 0; x < numbOf_tour; x++)
  1830.         {
  1831.             permaTemp = string[stringLength - 1];
  1832.             for (y = stringLength - 1; y>0; y--)
  1833.                 string[y] = string[y - 1];
  1834.             string[0] = permaTemp;
  1835.         }
  1836.     }
  1837. }
  1838.  
  1839. void string_leftRotation (char string[], int numbOf_tour)
  1840. {
  1841.     int stringLength = strlen(string);
  1842.    
  1843.     int x = 0;
  1844.     int y = 0;
  1845.    
  1846.     int permaTemp = 0;
  1847.     int temp = 0;
  1848.    
  1849.     if (stringLength > 1)
  1850.     {
  1851.         for (x = 0; x < numbOf_tour; x++)
  1852.         {
  1853.             permaTemp = string[0];
  1854.             for (y = 0; y < stringLength; y++)
  1855.             {
  1856.                 if (!y)
  1857.                     string[0] = string[1];
  1858.                 else
  1859.                 {
  1860.                     temp = string[y];
  1861.                     string[y] = string[y + 1];
  1862.                 }
  1863.             }
  1864.             string[y - 1] = permaTemp;
  1865.         }
  1866.     }
  1867. }
  1868.  
  1869. void string_reverse(char string[])
  1870. {
  1871.     int x = 0;
  1872.     int y = 0;
  1873.  
  1874.     char *temp = malloc(sizeof(char)*(strlen(string)+1));
  1875.  
  1876.  
  1877.     for (x = strlen(string) - 1, y = 0; x > -1; x--, y++)
  1878.         temp[y] = string[x];
  1879.     temp[y] = '\0';
  1880.  
  1881.     sprintf(string, "%s", temp);
  1882.  
  1883.     free(temp);
  1884. }
  1885.  
  1886. void subBox(char string[], char sub_Box[62][62][3])
  1887. {
  1888.     char backup = 0;
  1889.     backup = string[0];
  1890.  
  1891.     string[0] = sub_Box[searchCoord(string[0])][searchCoord(string[1])][0];
  1892.     string[1] = sub_Box[searchCoord(backup)][searchCoord(string[1])][1];
  1893.  
  1894.     backup = string[2];
  1895.     string[2] = sub_Box[searchCoord(string[2])][searchCoord(string[3])][0];
  1896.     string[3] = sub_Box[searchCoord(backup)][searchCoord(string[3])][1];
  1897.  
  1898.     backup = string[4];
  1899.     string[4] = sub_Box[searchCoord(string[4])][searchCoord(string[5])][0];
  1900.     string[5] = sub_Box[searchCoord(backup)][searchCoord(string[5])][1];
  1901.  
  1902.     backup = string[6];
  1903.     string[6] = sub_Box[searchCoord(string[6])][searchCoord(string[7])][0];
  1904.     string[7] = sub_Box[searchCoord(backup)][searchCoord(string[7])][1];
  1905.  
  1906. }
  1907.  
  1908. int searchCoord(char caracter)
  1909. {
  1910.     switch (caracter)
  1911.     {
  1912.     case '0':
  1913.         return 0;
  1914.         break;
  1915.  
  1916.     case '1':
  1917.         return 1;
  1918.         break;
  1919.  
  1920.     case '2':
  1921.         return 2;
  1922.         break;
  1923.  
  1924.     case '3':
  1925.         return 3;
  1926.         break;
  1927.  
  1928.     case '4':
  1929.         return 4;
  1930.         break;
  1931.  
  1932.     case '5':
  1933.         return 5;
  1934.         break;
  1935.  
  1936.     case '6':
  1937.         return 6;
  1938.         break;
  1939.  
  1940.     case '7':
  1941.         return 7;
  1942.         break;
  1943.  
  1944.     case '8':
  1945.         return 8;
  1946.         break;
  1947.  
  1948.     case '9':
  1949.         return 9;
  1950.         break;
  1951.  
  1952.     case 'A':
  1953.         return 10;
  1954.         break;
  1955.  
  1956.     case 'B':
  1957.         return 11;
  1958.         break;
  1959.  
  1960.     case 'C':
  1961.         return 12;
  1962.         break;
  1963.  
  1964.     case 'D':
  1965.         return 13;
  1966.         break;
  1967.  
  1968.     case 'E':
  1969.         return 14;
  1970.         break;
  1971.  
  1972.     case 'F':
  1973.         return 15;
  1974.         break;
  1975.  
  1976.     case 'G':
  1977.         return 16;
  1978.         break;
  1979.  
  1980.     case 'H':
  1981.         return 17;
  1982.         break;
  1983.  
  1984.     case 'I':
  1985.         return 18;
  1986.         break;
  1987.  
  1988.     case 'J':
  1989.         return 19;
  1990.         break;
  1991.  
  1992.     case 'K':
  1993.         return 20;
  1994.         break;
  1995.  
  1996.     case 'L':
  1997.         return 21;
  1998.         break;
  1999.  
  2000.     case 'M':
  2001.         return 22;
  2002.         break;
  2003.  
  2004.     case 'N':
  2005.         return 23;
  2006.         break;
  2007.  
  2008.     case 'O':
  2009.         return 24;
  2010.         break;
  2011.  
  2012.     case 'P':
  2013.         return 25;
  2014.         break;
  2015.  
  2016.     case 'Q':
  2017.         return 26;
  2018.         break;
  2019.  
  2020.     case 'R':
  2021.         return 27;
  2022.         break;
  2023.  
  2024.     case 'S':
  2025.         return 28;
  2026.         break;
  2027.  
  2028.     case 'T':
  2029.         return 29;
  2030.         break;
  2031.  
  2032.     case 'U':
  2033.         return 30;
  2034.         break;
  2035.  
  2036.     case 'V':
  2037.         return 31;
  2038.         break;
  2039.  
  2040.     case 'W':
  2041.         return 32;
  2042.         break;
  2043.  
  2044.     case 'X':
  2045.         return 33;
  2046.         break;
  2047.  
  2048.     case 'Y':
  2049.         return 34;
  2050.         break;
  2051.  
  2052.     case 'Z':
  2053.         return 35;
  2054.         break;
  2055.  
  2056.     case 'a':
  2057.         return 36;
  2058.         break;
  2059.  
  2060.     case 'b':
  2061.         return 37;
  2062.         break;
  2063.  
  2064.     case 'c':
  2065.         return 38;
  2066.         break;
  2067.  
  2068.     case 'd':
  2069.         return 39;
  2070.         break;
  2071.  
  2072.     case 'e':
  2073.         return 40;
  2074.         break;
  2075.  
  2076.     case 'f':
  2077.         return 41;
  2078.         break;
  2079.  
  2080.     case 'g':
  2081.         return 42;
  2082.         break;
  2083.  
  2084.     case 'h':
  2085.         return 43;
  2086.         break;
  2087.  
  2088.     case 'i':
  2089.         return 44;
  2090.         break;
  2091.  
  2092.     case 'j':
  2093.         return 45;
  2094.         break;
  2095.  
  2096.     case 'k':
  2097.         return 46;
  2098.         break;
  2099.  
  2100.     case 'l':
  2101.         return 47;
  2102.         break;
  2103.  
  2104.     case 'm':
  2105.         return 48;
  2106.         break;
  2107.  
  2108.     case 'n':
  2109.         return 49;
  2110.         break;
  2111.  
  2112.     case 'o':
  2113.         return 50;
  2114.         break;
  2115.  
  2116.     case 'p':
  2117.         return 51;
  2118.         break;
  2119.  
  2120.     case 'q':
  2121.         return 52;
  2122.         break;
  2123.  
  2124.     case 'r':
  2125.         return 53;
  2126.         break;
  2127.  
  2128.     case 's':
  2129.         return 54;
  2130.         break;
  2131.  
  2132.     case 't':
  2133.         return 55;
  2134.         break;
  2135.  
  2136.     case 'u':
  2137.         return 56;
  2138.         break;
  2139.  
  2140.     case 'v':
  2141.         return 57;
  2142.         break;
  2143.  
  2144.     case 'w':
  2145.         return 58;
  2146.         break;
  2147.  
  2148.     case 'x':
  2149.         return 59;
  2150.         break;
  2151.  
  2152.     case 'y':
  2153.         return 60;
  2154.         break;
  2155.  
  2156.     case 'z':
  2157.         return 61;
  2158.         break;
  2159.  
  2160.     }
  2161. }
  2162.  
  2163. short searchChar(int alpha)
  2164. {
  2165.     switch (alpha)
  2166.     {
  2167.         case 'A':
  2168.             return 0;
  2169.  
  2170.         case 'B':
  2171.             return 1;
  2172.  
  2173.         case 'C':
  2174.             return 2;
  2175.  
  2176.         case 'D':
  2177.             return 3;
  2178.  
  2179.         case 'E':
  2180.             return 4;
  2181.  
  2182.         case 'F':
  2183.             return 5;
  2184.  
  2185.         case 'G':
  2186.             return 6;
  2187.  
  2188.         case 'H':
  2189.             return 7;
  2190.  
  2191.         case 'I':
  2192.             return 8;
  2193.  
  2194.         case 'J':
  2195.             return 9;
  2196.  
  2197.         case 'K':
  2198.             return 10;
  2199.  
  2200.         case 'L':
  2201.             return 11;
  2202.  
  2203.         case 'M':
  2204.             return 12;
  2205.  
  2206.         case 'N':
  2207.             return 13;
  2208.  
  2209.         case 'O':
  2210.             return 14;
  2211.  
  2212.         case 'P':
  2213.             return 15;
  2214.  
  2215.         case 'Q':
  2216.             return 16;
  2217.  
  2218.         case 'R':
  2219.             return 17;
  2220.  
  2221.         case 'S':
  2222.             return 18;
  2223.  
  2224.         case 'T':
  2225.             return 19;
  2226.  
  2227.         case 'U':
  2228.             return 20;
  2229.  
  2230.         case 'V':
  2231.             return 21;
  2232.  
  2233.         case 'W':
  2234.             return 22;
  2235.  
  2236.         case 'X':
  2237.             return 23;
  2238.  
  2239.         case 'Y':
  2240.             return 24;
  2241.  
  2242.         case 'Z':
  2243.             return 25;
  2244.  
  2245.         case 'a':
  2246.             return 26;
  2247.  
  2248.         case 'b':
  2249.             return 27;
  2250.  
  2251.         case 'c':
  2252.             return 28;
  2253.  
  2254.         case 'd':
  2255.             return 29;
  2256.  
  2257.         case 'e':
  2258.             return 30;
  2259.  
  2260.         case 'f':
  2261.             return 31;
  2262.  
  2263.         case 'g':
  2264.             return 32;
  2265.  
  2266.         case 'h':
  2267.             return 33;
  2268.  
  2269.         case 'i':
  2270.             return 34;
  2271.  
  2272.         case 'j':
  2273.             return 35;
  2274.  
  2275.         case 'k':
  2276.             return 36;
  2277.  
  2278.         case 'l':
  2279.             return 37;
  2280.  
  2281.         case 'm':
  2282.             return 38;
  2283.  
  2284.         case 'n':
  2285.             return 39;
  2286.  
  2287.         case 'o':
  2288.             return 40;
  2289.  
  2290.         case 'p':
  2291.             return 41;
  2292.  
  2293.         case 'q':
  2294.             return 42;
  2295.  
  2296.         case 'r':
  2297.             return 43;
  2298.  
  2299.         case 's':
  2300.             return 44;
  2301.  
  2302.         case 't':
  2303.             return 45;
  2304.  
  2305.         case 'u':
  2306.             return 46;
  2307.  
  2308.         case 'v':
  2309.             return 47;
  2310.  
  2311.         case 'w':
  2312.             return 48;
  2313.  
  2314.         case 'x':
  2315.             return 49;
  2316.  
  2317.         case 'y':
  2318.             return 50;
  2319.  
  2320.         case 'z':
  2321.             return 51;
  2322.  
  2323.         case '0':
  2324.             return 52;
  2325.  
  2326.         case '1':
  2327.             return 53;
  2328.  
  2329.         case '2':
  2330.             return 54;
  2331.  
  2332.         case '3':
  2333.             return 55;
  2334.  
  2335.         case '4':
  2336.             return 56;
  2337.  
  2338.         case '5':
  2339.             return 57;
  2340.  
  2341.         case '6':
  2342.             return 58;
  2343.  
  2344.         case '7':
  2345.             return 59;
  2346.  
  2347.         case '8':
  2348.             return 60;
  2349.  
  2350.         case '9':
  2351.             return 61;
  2352.  
  2353.         case '!':
  2354.             return 62;
  2355.            
  2356.         case '\"':
  2357.             return 63;
  2358.            
  2359.         case '#':
  2360.             return 64;
  2361.            
  2362.         case '$':
  2363.             return 65;
  2364.            
  2365.         case '%' :
  2366.             return 66;
  2367.  
  2368.         case '&':
  2369.             return 67;
  2370.            
  2371.         case '(':
  2372.             return 68;
  2373.  
  2374.         case ')':
  2375.             return 69;
  2376.  
  2377.         case '*':
  2378.             return 70;
  2379.  
  2380.         case '+':
  2381.             return 71;
  2382.            
  2383.         case ',':
  2384.             return 72;
  2385.  
  2386.         case '-':
  2387.             return 73;
  2388.  
  2389.         case '.':
  2390.             return 74;
  2391.            
  2392.         case '/':
  2393.             return 75;
  2394.  
  2395.         case ':':
  2396.             return 76;
  2397.            
  2398.         case ';':
  2399.             return 77;
  2400.            
  2401.         case '<':
  2402.             return 78;
  2403.  
  2404.         case '=':
  2405.             return 79;
  2406.            
  2407.         case '>':
  2408.             return 80;
  2409.            
  2410.         case '?':
  2411.             return 81;
  2412.            
  2413.         case '@':
  2414.             return 82;
  2415.            
  2416.         case '[':
  2417.             return 83;
  2418.            
  2419.         case ']':
  2420.             return 84;
  2421.            
  2422.         case '^':
  2423.             return 85;
  2424.            
  2425.         case '_':
  2426.             return 86;
  2427.            
  2428.         case '`':
  2429.             return 87;
  2430.            
  2431.         case '{':
  2432.             return 88;
  2433.            
  2434.         case '|':
  2435.             return 89;
  2436.            
  2437.         case '}':
  2438.             return 90;
  2439.            
  2440.         case '~':
  2441.             return 91;
  2442.            
  2443.         case ' ':
  2444.             return 92;
  2445.  
  2446.         case '\'':
  2447.             return 93;
  2448.  
  2449.         default:
  2450.             return 0;
  2451.     }
  2452. }
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!