foundational_lib 1.0 → 1.0.1

data/platforms/header_and_separate_compilation_unit/foundationallib_noninline.c

@@ -116,7 +116,7 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 
 #endif
 #ifndef FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED
-// Default true
+/* Default true */
 #define FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED 1
 #endif
 
@@ -332,7 +332,7 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 #endif
 
 #ifndef FOUNDATIONAL_LIB_FPUTC
-#define FOUNDATIONAL_LIB_FPUTC putc
+#define FOUNDATIONAL_LIB_FPUTC fputc
 #endif
 
 #ifndef FOUNDATIONAL_LIB_STRPBRK
@@ -419,10 +419,10 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 #endif
 
 #if defined(__GNUC__) || defined(__clang__)
-#define FOUNDATIONAL_LIB_likely(x) __builtin_expect(!!(x), 1)
+#define FOUNDATIONAL_LIB_LIKELY(x) __builtin_expect(!!(x), 1)
 #define FOUNDATIONAL_LIB_UNLIKELY(x) __builtin_expect(!!(x), 0)
 #else
-#define FOUNDATIONAL_LIB_likely(x) (x)
+#define FOUNDATIONAL_LIB_LIKELY(x) (x)
 #define FOUNDATIONAL_LIB_UNLIKELY(x) (x)
 #endif
 
@@ -439,8 +439,12 @@ FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE
 #endif /* assert checking. */
 
 #ifdef __GNUC__
-/** @brief Safely multiply 2 numbers to avoid unsigned integer overflows and security and stability issues. We never, NEVER want any of those things. Ever. */
-FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_CONST size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
+/**
+ * @brief
+ * Safely multiply 2 numbers to avoid unsigned integer overflows and security
+ * and stability issues. We never, NEVER want any of those things. Ever.
+ */
+FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_PURE size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
 {
     size_t result;
 
@@ -520,8 +524,12 @@ FOUNDATIONAL_LIB_NOTHROW /** @brief Safely add 3 numbers to avoid unsigned integ
 }
 
 #else  /* GNUC */
-/** @brief Safely multiply 2 numbers to avoid unsigned integer overflows and security and stability issues. We never, NEVER want any of those things. Ever. */
-FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_CONST size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
+/**
+ * @brief
+ * Safely multiply 2 numbers to avoid unsigned integer overflows and security
+ * and stability issues. We never, NEVER want any of those things. Ever.
+ */
+FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_PURE size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
 {
     size_t result;
 
@@ -611,7 +619,6 @@ FOUNDATIONAL_LIB_NOTHROW int FOUNDATIONAL_LIB_safe_add_3_ptr(size_t a, size_t b,
 
 // Adjust as needed. On embedded platforms or low memory systems, you might want to change the algorithm to be somewhat lower than 1.5x
 // new len calculations need to be checked, before and after this, for overflow.
-
 #ifndef FOUNDATIONAL_LIB_LOW_MEMORY_USAGE
 #define FOUNDATIONAL_LIB_LOW_MEMORY_USAGE 12
 #endif
@@ -2101,7 +2108,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%d", *array[i]);
         if (i < size - 1)
@@ -2127,7 +2134,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lu", array[i]);
         if (i < size - 1)
@@ -2154,7 +2161,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lu", *array[i]);
         if (i < size - 1)
@@ -2179,7 +2186,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%ld", array[i]);
         if (i < size - 1)
@@ -2206,7 +2213,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%ld", *array[i]);
         if (i < size - 1)
@@ -2233,7 +2240,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const unsigned long long value = array[i];
         char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
@@ -2264,7 +2271,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const unsigned long long value = *(array[i]);
         char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
@@ -2294,7 +2301,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const unsigned long long value = array[i];
         char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
@@ -2327,7 +2334,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         const long long value = *(array[i]);
 
@@ -2358,7 +2365,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%f", array[i]);
         if (i < size - 1)
@@ -2385,7 +2392,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%f", *array[i]);
         if (i < size - 1)
@@ -2411,7 +2418,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lf", array[i]);
         if (i < size - 1)
@@ -2438,7 +2445,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         FOUNDATIONAL_LIB_FPRINTF(stream, "%lf", *array[i]);
         if (i < size - 1)
@@ -2464,7 +2471,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpragmas"
@@ -2497,7 +2504,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void pri
 {
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_FPUTC('[', stream);
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpragmas"
@@ -2548,7 +2555,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
         return NULL;
     }
 
-    for (size_t i = 0; i < tot_size; i++)
+    for (size_t i = 0; i < tot_size; ++i)
     {
         duplicate[i] = ((char *)array)[i];
     }
@@ -3402,7 +3409,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NO
     const char *ptr;
 
     /* Split the string into tokens */
-    for (size_t i = 0; i < *output_size; i++)
+    for (size_t i = 0; i < *output_size; ++i)
     {
         ptr = FOUNDATIONAL_LIB_STRSTR(token_start, delim);
 
@@ -3502,7 +3509,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NO
     size_t total_length;
 
     total_length = 1; // NUL byte
-    for (size_t i = 0; i < count; i++)
+    for (size_t i = 0; i < count; ++i)
     {
         const size_t new_len = FOUNDATIONAL_LIB_STRLEN(array[i]);
         lens[i] = new_len;
@@ -4116,7 +4123,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_PURE FOUNDATIONAL_LIB_NOTHROW FOUNDATI
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     size_t length = 0;
 
-    for (size_t i = 0; i < count; i++)
+    for (size_t i = 0; i < count; ++i)
     {
         // NOTE: Do not check for overflows here.
         length += FOUNDATIONAL_LIB_STRLEN(array[i]);
@@ -4215,7 +4222,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
     size_t length = FOUNDATIONAL_LIB_STRLEN(new_str);
     size_t i, j;
 
-    for (i = 0, j = length - 1; i < j; i++, j--)
+    for (i = 0, j = length - 1; i < j; ++i, j--)
     {
         char temp = new_str[i];
         new_str[i] = new_str[j];
@@ -4532,7 +4539,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     const size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
-    for (size_t i = 0; i < len; i++)
+    for (size_t i = 0; i < len; ++i)
     {
         if (!FOUNDATIONAL_LIB_ISDIGIT(str[i]))
         {
@@ -4563,7 +4570,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
-    for (size_t i = 0; i < len; i++)
+    for (size_t i = 0; i < len; ++i)
     {
         if (!FOUNDATIONAL_LIB_ISALNUM(str[i]))
         {
@@ -4771,7 +4778,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     const char *result = strpbrk(str, char_set);
 
-    return FOUNDATIONAL_LIB_likely(result != NULL) ? result - str : -1;
+    return FOUNDATIONAL_LIB_LIKELY(result != NULL) ? result - str : -1;
 }
 
 /**
@@ -4889,7 +4896,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     const size_t min_len = (len1 < len2) ? len1 : len2;
 
-    for (size_t i = 0; i < min_len; i++)
+    for (size_t i = 0; i < min_len; ++i)
     {
         if (str1[i] != str2[i])
         {
@@ -4919,7 +4926,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     const size_t min_len = (len1 < len2) ? len1 : len2;
 
-    for (size_t i = 1; i <= min_len; i++)
+    for (size_t i = 1; i <= min_len; ++i)
     {
         if (str1[len1 - i] != str2[len2 - i])
         {
@@ -4961,7 +4968,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     int make_upper = 1; // Start with the first character as uppercase
 
-    for (size_t i = 0; i < len; i++)
+    for (size_t i = 0; i < len; ++i)
     {
         if (FOUNDATIONAL_LIB_ISSPACE(str[i]))
         {
@@ -5000,7 +5007,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     int max = array[0];
 
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         if (array[i] > max)
         {
@@ -5031,7 +5038,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
 
     int min = array[0];
 
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         if (array[i] < min)
         {
@@ -7741,7 +7748,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
  *
  *        If should_free_after_use is non-zero, a new dynamically allocated array with the replacements made.
  *        If should_free_after_use is zero, output aliases source, and they refer to the same memory.
- * @param should_free_after_use A pointer to a int indicating whether
+ * @param should_free_after_use A pointer to a int indicating whether one should free the memory after using the function.
  * @param num_matches A pointer to a variable to store the number of replacements made.
  * @param matches_max A pointer to the maximum number of replacements to make. If zero, there is no maximum.
  *
@@ -8254,7 +8261,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void map
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform);
 
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         array[i] = transform(array[i]);
     }
@@ -8297,7 +8304,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(operation);
 
     int result = array[0];
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         result = operation(result, array[i]);
     }
@@ -8350,7 +8357,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(condition);
 
     size_t count = 0;
-    for (size_t i = 0; i < source_size; i++)
+    for (size_t i = 0; i < source_size; ++i)
     {
         if (condition(source[i]))
         {
@@ -8395,7 +8402,7 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void map
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
     FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform);
 
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         transform(((char *)array) + i * elem_size);
     }
@@ -8445,12 +8452,12 @@ FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NOTHROW FOUNDATIONAL_LIB_FUNC void red
     char *char_result = (char *)result;
 
     /* Initialize the result with the first element */
-    for (size_t i = 0; i < elem_size; i++)
+    for (size_t i = 0; i < elem_size; ++i)
     {
         char_result[i] = char_array[i];
     }
 
-    for (size_t i = 1; i < size; i++)
+    for (size_t i = 1; i < size; ++i)
     {
         operation(char_result, char_array + i * elem_size);
     }
@@ -8508,18 +8515,19 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
     char *char_destination = (char *)destination;
 
     size_t count = 0;
-    for (size_t i = 0; i < source_size; i++)
+    for (size_t i = 0; i < source_size; ++i)
     {
         if (condition(char_source + i * elem_size))
         {
             if (count < dest_size)
             {
-                for (size_t j = 0; j < elem_size; j++)
+                for (size_t j = 0; j < elem_size; ++j)
                 {
                     char_destination[count * elem_size + j] = char_source[i * elem_size + j];
                 }
             }
-            count++;
+
+            ++count;
         }
     }
     return count;
@@ -9598,18 +9606,18 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
     }
 
     // Initialize all elements to NULL
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         (*output)[i] = NULL;
     }
 
     // Iterate through the input array to find unique strings
-    for (size_t i = 0; i < size; i++)
+    for (size_t i = 0; i < size; ++i)
     {
         int is_unique = 1;
 
         // Check if the current string is not equal to any previous strings
-        for (size_t j = 0; j < count; j++)
+        for (size_t j = 0; j < count; ++j)
         {
             if ((*output)[j] != NULL && FOUNDATIONAL_LIB_STRCMP(array[i], (*output)[j]) == 0)
             {
@@ -12012,7 +12020,7 @@ FOUNDATIONAL_LIB_WARN_UNUSED_RESULT FOUNDATIONAL_LIB_NONNULL FOUNDATIONAL_LIB_NO
         if ((str[i] & 0x80) == 0)
         {
             // ASCII character (0xxxxxxx)
-            i++;
+            ++i;
         }
         else if ((str[i] & 0xE0) == 0xC0)
         {