1. #include <stdio.h>   // for printf
2. #include <stdlib.h>  // for malloc
3. #include <string.h>  // for string manipulation functions
4. #include <intrin.h>  // for intrinsic functions (specific to certain compilers and architectures)
5. #include <immintrin.h>
6. #include <cstdint>
7. #include <math.h>
8.  
9. #define MAX_STR 256
10.  
11. int b64_distance(char str1[MAX_STR], char str2[MAX_STR]){
12.     char newStr1[MAX_STR];
13.     char newStr2[MAX_STR];
14.     int b64_1[6];
15.     int b64_2[6];
16.     char arr1[6];
17.     char arr2[6];
18.    
19.     memset(newStr1, 0, sizeof(newStr1));
20.     memset(newStr2, 0, sizeof(newStr2));
21.     memset(b64_1, 0, sizeof(b64_1));
22.     memset(b64_2, 0, sizeof(b64_2));
23.  
24.     int newStr1_len = removeNonBase64(str1, newStr1);
25.     int newStr2_len = removeNonBase64(str2, newStr2);
26.  
27.     //take only the relevant part of the arrey
28.     relevantPart (newStr1, arr1, newStr1_len);
29.     relevantPart (newStr2, arr2, newStr2_len);
30.  
31.     //convert to base64
32.     // convertTob64(arr1, b64_1);
33.     // convertTob64(arr2, b64_2);
34.    
35.     //convert to decimal
36.     int num1 = b64ToDecimal(b64_1);
37.     int num2 = b64ToDecimal(b64_2);
38.  
39.     return num1 - num2;
40. }
41.  
42.  
43. int removeNonBase64 (char *src, char *dest)
44. {
45.     int src_len = strlen(src);
46.     int dest_len = 0;
47.     for(int i = 0; i < src_len; i++){
48.         if('A' <= src[i] && src[i] <= 'Z'){
49.             dest[dest_len] = src[i] - 'A';
50.             dest_len++;
51.         }
52.         else if('a' <= src[i] && src[i] <= 'z'){
53.             dest[dest_len] = src[i] -'a' + 26;
54.             dest_len++;
55.         }
56.         else if('0' <= src[i] && src[i] <= '9'){
57.             dest[dest_len] = src[i] -'0' + 52;
58.             dest_len++;
59.         }
60.         else if(src[i] == '+'){
61.             dest[dest_len] = src[i] + 62;
62.             dest_len++;
63.         }
64.         else if(src[i] == '/'){
65.             dest[dest_len] = src[i] + 63;
66.             dest_len++;
67.         }
68.     }
69.     return dest_len;
70. }
71.  
72. void relevantPart (char *src, char dest[6], int src_len)
73. {
74.     if(src_len >= 6)
75.     {
76.         for(int i = 0; i < 6 ; i++)
77.         {
78.             dest[6 - i] = src[src_len - i];
79.         }
80.     }
81.     else
82.     {
83.         int i;
84.         for(i = 0; i < src_len ; i++)
85.         {
86.             dest[6 - i] = src[src_len - i];
87.         }
88.  
89.         for(; i < 6 ; i++)
90.         {
91.             dest[6 - i] = 'A';
92.         }
93.     }
94.     return;
95. }
96.  
97. void convertTob64()
98. {
99. //a-z
100.  
101. //A-Z
102.  
103. //0-9
104.  
105. //+
106.  
107. // /
108.  
109. }
110.  
111. int b64ToDecimal (int* arr)
112. {
113.     int temp[4];
114.     for(int i = 5; i < 2; i--)
115.     {
116.         temp[i] = pow(64, i);
117.     }
118.  
119.     _m128i xmm1 = _mm_lddqu_si128((_m128i *)arr);
120.     _m128i xmm2 = _mm_lddqu_si128((_m128i *)temp);
121.  
122.     __m128i resultxmm = _mm_mul_epi32(xmm1, xmm2);
123.  
124.      int horiz 0) +
125.                          _mm_extract_epi32(resultxmm, 1) +
126.                          _mm_extract_epi32(resultxmm, 2) +
127.                          _mm_extract_epi32(resultxmm, 3) +
128.                          (arr[4] * 64) +
129.                          arr[5];
130.  
131.     return horizontal_sum;
132. }
133.  
134.  
135.  
136.  
137.  
138.  
139.  
140.  
141.  
142.  
143.  
144. uint16_t getBitPattern(char c[16]){
145.     __m128i ranges = _mm_set_epi8(0, 0, 0, 0, 0, 0, '/', '/', '+', '+', 'z', 'a', '9', '0', 'Z', 'A');
146.     _m128i chars = _mm_lddqu_si128((_m128i *)c);
147.  
148.     __m128i result = _mm_cmpistrm(ranges, chars, _SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_BIT_MASK);
149.  
150.     uint16_t intResults = _mm_extract_epi16(result, 0);
151.     return intResults;
152. }