From: Kevin Day <thekevinday@gmail.com>
Date: Wed, 23 Feb 2022 04:04:15 +0000 (-0600)
Subject: Update: IKI Improvements and some cleanups.
X-Git-Tag: 0.5.8~12
X-Git-Url: https://git.kevux.org/?a=commitdiff_plain;h=f191f458949a3ee733a44d23fb80df5ecc854e58;p=fll

Update: IKI Improvements and some cleanups.

The _di_X_t_ where "X" is something like f_fss_object, is missing the leading "f_" in several cases.

Make the *_increase() step variable an f_array_length_t.
Rather than trying to optimize, just guarantee whatever step size is desired is available.

Move the iki_read programs practice of defining an iki_data_t structure into the level_0 iki project.
This then allows simplifying the arguments passed to the iki read functions.
---

diff --git a/level_0/f_fss/c/fss/common.h b/level_0/f_fss/c/fss/common.h
index b232360..d56af4d 100644
--- a/level_0/f_fss/c/fss/common.h
+++ b/level_0/f_fss/c/fss/common.h
@@ -255,13 +255,13 @@ enum {
 /**
  * This is a range that represents an object.
  */
-#ifndef _di_fss_object_t_
+#ifndef _di_f_fss_object_t_
   typedef f_string_range_t f_fss_object_t;
 
   #define f_fss_object_t_initialize f_string_range_t_initialize
 
   #define macro_f_fss_object_t_clear(object) macro_f_string_range_t_clear(object)
-#endif // _di_fss_object_t_
+#endif // _di_f_fss_object_t_
 
 /**
  * This holds an array of fss_object.
@@ -270,7 +270,7 @@ enum {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_fss_objects_t_
+#ifndef _di_f_fss_objects_t_
   typedef f_string_ranges_t f_fss_objects_t;
 
   #define f_fss_objects_t_initialize f_string_ranges_t_initialize
@@ -287,7 +287,7 @@ enum {
   #define macro_f_fss_objects_t_increase_by(status, objects, amount) macro_f_string_ranges_t_increase_by(status, objects, amount)
   #define macro_f_fss_objects_t_decrease_by(status, objects, amount) macro_f_string_ranges_t_decrease_by(status, objects, amount)
   #define macro_f_fss_objects_t_decimate_by(status, objects, amount) macro_f_string_ranges_t_decimate_by(status, objects, amount)
-#endif // _di_fss_objects_t_
+#endif // _di_f_fss_objects_t_
 
 /**
  * This holds an array of string ranges that represent the content.
@@ -298,7 +298,7 @@ enum {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_fss_content_
+#ifndef _di_f_fss_content_
   typedef f_string_ranges_t f_fss_content_t;
 
   #define f_fss_content_t_initialize f_string_ranges_t_initialize
@@ -315,7 +315,7 @@ enum {
   #define macro_f_fss_content_t_increase_by(status, content, amount) macro_f_string_ranges_t_increase_by(status, content, amount)
   #define macro_f_fss_content_t_decrease_by(status, content, amount) macro_f_string_ranges_t_decrease_by(status, content, amount)
   #define macro_f_fss_content_t_decimate_by(status, content, amount) macro_f_string_ranges_t_decimate_by(status, content, amount)
-#endif // _di_fss_content_
+#endif // _di_f_fss_content_
 
 /**
  * This holds an array of fss_content.
diff --git a/level_0/f_fss/c/fss/named.c b/level_0/f_fss/c/fss/named.c
index af2cdcf..3070c5e 100644
--- a/level_0/f_fss/c/fss/named.c
+++ b/level_0/f_fss/c/fss/named.c
@@ -46,7 +46,7 @@ extern "C" {
 #endif // _di_f_fss_named_decrease_by_
 
 #ifndef _di_f_fss_named_increase_
-  f_status_t f_fss_named_increase(const uint16_t step, f_fss_named_t * const named) {
+  f_status_t f_fss_named_increase(const f_array_length_t step, f_fss_named_t * const named) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!named) return F_status_set_error(F_parameter);
@@ -140,7 +140,7 @@ extern "C" {
 #endif // _di_f_fss_nameds_decrease_by_
 
 #ifndef _di_f_fss_nameds_increase_
-  f_status_t f_fss_nameds_increase(const uint16_t step, f_fss_nameds_t * const nameds) {
+  f_status_t f_fss_nameds_increase(const f_array_length_t step, f_fss_nameds_t * const nameds) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!nameds) return F_status_set_error(F_parameter);
diff --git a/level_0/f_fss/c/fss/named.h b/level_0/f_fss/c/fss/named.h
index 792922e..b505175 100644
--- a/level_0/f_fss/c/fss/named.h
+++ b/level_0/f_fss/c/fss/named.h
@@ -63,7 +63,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_fss_nameds_t_
+#ifndef _di_f_fss_nameds_t_
   typedef struct {
     f_fss_named_t *array;
 
@@ -85,7 +85,7 @@ extern "C" {
   #define macro_f_fss_nameds_t_increase_by(status, nameds, amount) status = f_fss_nameds_increase_by(amount, &nameds);
   #define macro_f_fss_nameds_t_decrease_by(status, nameds, amount) status = f_fss_nameds_decrease_by(amount, &nameds);
   #define macro_f_fss_nameds_t_decimate_by(status, nameds, amount) status = f_fss_nameds_decimate_by(amount, &nameds);
-#endif // _di_fss_nameds_t_
+#endif // _di_f_fss_nameds_t_
 
 /**
  * Resize all parts of the named structure using the same length.
@@ -170,7 +170,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_named_increase_
-  extern f_status_t f_fss_named_increase(const uint16_t step, f_fss_named_t * const named);
+  extern f_status_t f_fss_named_increase(const f_array_length_t step, f_fss_named_t * const named);
 #endif // _di_f_fss_named_increase_
 
 /**
@@ -298,7 +298,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_nameds_increase_
-  extern f_status_t f_fss_nameds_increase(const uint16_t step, f_fss_nameds_t * const nameds);
+  extern f_status_t f_fss_nameds_increase(const f_array_length_t step, f_fss_nameds_t * const nameds);
 #endif // _di_f_fss_nameds_increase_
 
 /**
diff --git a/level_0/f_fss/c/fss/nest.c b/level_0/f_fss/c/fss/nest.c
index 04da6a8..c760ec7 100644
--- a/level_0/f_fss/c/fss/nest.c
+++ b/level_0/f_fss/c/fss/nest.c
@@ -46,7 +46,7 @@ extern "C" {
 #endif // _di_f_fss_items_decrease_by_
 
 #ifndef _di_f_fss_items_increase_
-  f_status_t f_fss_items_increase(const uint16_t step, f_fss_items_t * const items) {
+  f_status_t f_fss_items_increase(const f_array_length_t step, f_fss_items_t * const items) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!items) return F_status_set_error(F_parameter);
@@ -140,7 +140,7 @@ extern "C" {
 #endif // _di_f_fss_nest_decrease_by_
 
 #ifndef _di_f_fss_nest_increase_
-  f_status_t f_fss_nest_increase(const uint16_t step, f_fss_nest_t * const nest) {
+  f_status_t f_fss_nest_increase(const f_array_length_t step, f_fss_nest_t * const nest) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!nest) return F_status_set_error(F_parameter);
@@ -234,7 +234,7 @@ extern "C" {
 #endif // _di_f_fss_nests_decrease_by_
 
 #ifndef _di_f_fss_nests_increase_
-  f_status_t f_fss_nests_increase(const uint16_t step, f_fss_nests_t * const nests) {
+  f_status_t f_fss_nests_increase(const f_array_length_t step, f_fss_nests_t * const nests) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!nests) return F_status_set_error(F_parameter);
diff --git a/level_0/f_fss/c/fss/nest.h b/level_0/f_fss/c/fss/nest.h
index ce38da1..c89c857 100644
--- a/level_0/f_fss/c/fss/nest.h
+++ b/level_0/f_fss/c/fss/nest.h
@@ -31,7 +31,7 @@ extern "C" {
  * content: The content associated with the object.
  * parent:  A location referencing a parrent object or content that this object content is nested under.
  */
-#ifndef _di_fss_item_t_
+#ifndef _di_f_fss_item_t_
   typedef struct {
     f_fss_object_t object;
     f_fss_content_t content;
@@ -56,7 +56,7 @@ extern "C" {
   #define macro_f_fss_item_t_increase_by(status, item, amount) macro_f_fss_content_t_increase_by(status, item.content, amount)
   #define macro_f_fss_item_t_decrease_by(status, item, amount) macro_f_fss_content_t_decrease_by(status, item.content, amount)
   #define macro_f_fss_item_t_decimate_by(status, item, amount) macro_f_fss_content_t_decimate_by(status, item.content, amount)
-#endif // _di_fss_item_t_
+#endif // _di_f_fss_item_t_
 
 /**
  * This holds an array of fss_item.
@@ -86,7 +86,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_fss_items_t_
+#ifndef _di_f_fss_items_t_
   typedef struct {
     f_fss_item_t *array;
 
@@ -108,7 +108,7 @@ extern "C" {
   #define macro_f_fss_items_t_increase_by(status, items, amount) status = f_fss_items_increase_by(amount, &items);
   #define macro_f_fss_items_t_decrease_by(status, items, amount) status = f_fss_items_decrease_by(amount, &items);
   #define macro_f_fss_items_t_decimate_by(status, items, amount) status = f_fss_items_decimate_by(amount, &items);
-#endif // _di_fss_items_t_
+#endif // _di_f_fss_items_t_
 
 /**
  * This holds an array of f_fss_items_t.
@@ -122,7 +122,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_fss_nest_t_
+#ifndef _di_f_fss_nest_t_
   typedef struct {
     f_fss_items_t *depth;
 
@@ -144,7 +144,7 @@ extern "C" {
   #define macro_f_fss_nest_t_increase_by(status, nest, amount) status = f_fss_nest_increase_by(amount, &nest);
   #define macro_f_fss_nest_t_decrease_by(status, nest, amount) status = f_fss_nest_decrease_by(amount, &nest);
   #define macro_f_fss_nest_t_decimate_by(status, nest, amount) status = f_fss_nest_decimate_by(amount, &nest);
-#endif // _di_fss_nest_t_
+#endif // _di_f_fss_nest_t_
 
 /**
  * This holds an array of f_fss_nest_t.
@@ -153,7 +153,7 @@ extern "C" {
  * size: Total amount of allocated space.
  * used: Total number of allocated spaces used.
  */
-#ifndef _di_fss_nests_t_
+#ifndef _di_f_fss_nests_t_
   typedef struct {
     f_fss_nest_t *array;
 
@@ -175,7 +175,7 @@ extern "C" {
   #define macro_f_fss_nests_t_increase_by(status, nests, amount) status = f_fss_nests_increase_by(amount, &nests);
   #define macro_f_fss_nests_t_decrease_by(status, nests, amount) status = f_fss_nests_decrease_by(amount, &nests);
   #define macro_f_fss_nests_t_decimate_by(status, nests, amount) status = f_fss_nests_decimate_by(amount, &nests);
-#endif // _di_fss_nests_t_
+#endif // _di_f_fss_nests_t_
 
 /**
  * Resize the nest array.
@@ -260,7 +260,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_items_increase_
-  extern f_status_t f_fss_items_increase(const uint16_t step, f_fss_items_t * const items);
+  extern f_status_t f_fss_items_increase(const f_array_length_t step, f_fss_items_t * const items);
 #endif // _di_f_fss_items_increase_
 
 /**
@@ -388,7 +388,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_nest_increase_
-  extern f_status_t f_fss_nest_increase(const uint16_t step, f_fss_nest_t * const nest);
+  extern f_status_t f_fss_nest_increase(const f_array_length_t step, f_fss_nest_t * const nest);
 #endif // _di_f_fss_nest_increase_
 
 /**
@@ -516,7 +516,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_nests_increase_
-  extern f_status_t f_fss_nests_increase(const uint16_t step, f_fss_nests_t * const nests);
+  extern f_status_t f_fss_nests_increase(const f_array_length_t step, f_fss_nests_t * const nests);
 #endif // _di_f_fss_nests_increase_
 
 /**
diff --git a/level_0/f_fss/c/fss/set.c b/level_0/f_fss/c/fss/set.c
index 2ec0998..09f524d 100644
--- a/level_0/f_fss/c/fss/set.c
+++ b/level_0/f_fss/c/fss/set.c
@@ -46,7 +46,7 @@ extern "C" {
 #endif // _di_f_fss_set_decrease_by_
 
 #ifndef _di_f_fss_set_increase_
-  f_status_t f_fss_set_increase(const uint16_t step, f_fss_set_t * const set) {
+  f_status_t f_fss_set_increase(const f_array_length_t step, f_fss_set_t * const set) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!set) return F_status_set_error(F_parameter);
@@ -140,7 +140,7 @@ extern "C" {
 #endif // _di_f_fss_set_quote_decrease_by_
 
 #ifndef _di_f_fss_set_quote_increase_
-  f_status_t f_fss_set_quote_increase(const uint16_t step, f_fss_set_quote_t * const set_quote) {
+  f_status_t f_fss_set_quote_increase(const f_array_length_t step, f_fss_set_quote_t * const set_quote) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!set_quote) return F_status_set_error(F_parameter);
@@ -234,7 +234,7 @@ extern "C" {
 #endif // _di_f_fss_set_quotes_decrease_by_
 
 #ifndef _di_f_fss_set_quotes_increase_
-  f_status_t f_fss_set_quotes_increase(const uint16_t step, f_fss_set_quotes_t * const set_quotes) {
+  f_status_t f_fss_set_quotes_increase(const f_array_length_t step, f_fss_set_quotes_t * const set_quotes) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!set_quotes) return F_status_set_error(F_parameter);
@@ -328,7 +328,7 @@ extern "C" {
 #endif // _di_f_fss_sets_decrease_by_
 
 #ifndef _di_f_fss_sets_increase_
-  f_status_t f_fss_sets_increase(const uint16_t step, f_fss_sets_t * const sets) {
+  f_status_t f_fss_sets_increase(const f_array_length_t step, f_fss_sets_t * const sets) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!sets) return F_status_set_error(F_parameter);
diff --git a/level_0/f_fss/c/fss/set.h b/level_0/f_fss/c/fss/set.h
index 451056e..7533165 100644
--- a/level_0/f_fss/c/fss/set.h
+++ b/level_0/f_fss/c/fss/set.h
@@ -127,7 +127,7 @@ extern "C" {
  * size:  total amount of allocated space.
  * used:  total number of allocated spaces used.
  */
-#ifndef _di_fss_set_quotes_t_
+#ifndef _di_f_fss_set_quotes_t_
   typedef struct {
     f_fss_set_quote_t *array;
 
@@ -149,7 +149,7 @@ extern "C" {
   #define macro_f_fss_set_quotes_t_increase_by(status, set_quotes, amount) status = f_fss_set_quotes_increase_by(amount, &set_quotes);
   #define macro_f_fss_set_quotes_t_decrease_by(status, set_quotes, amount) status = f_fss_set_quotes_decrease_by(amount, &set_quotes);
   #define macro_f_fss_set_quotes_t_decimate_by(status, set_quotes, amount) status = f_fss_set_quotes_decimate_by(amount, &set_quotes);
-#endif // _di_fss_set_quotes_t_
+#endif // _di_f_fss_set_quotes_t_
 
 /**
  * Resize the set array.
@@ -234,7 +234,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_set_increase_
-  extern f_status_t f_fss_set_increase(const uint16_t step, f_fss_set_t * const set);
+  extern f_status_t f_fss_set_increase(const f_array_length_t step, f_fss_set_t * const set);
 #endif // _di_f_fss_set_increase_
 
 /**
@@ -362,7 +362,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_set_quote_increase_
-  extern f_status_t f_fss_set_quote_increase(const uint16_t step, f_fss_set_quote_t * const set_quote);
+  extern f_status_t f_fss_set_quote_increase(const f_array_length_t step, f_fss_set_quote_t * const set_quote);
 #endif // _di_f_fss_set_quote_increase_
 
 /**
@@ -490,7 +490,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_set_quotes_increase_
-  extern f_status_t f_fss_set_quotes_increase(const uint16_t step, f_fss_set_quotes_t * const set_quotes);
+  extern f_status_t f_fss_set_quotes_increase(const f_array_length_t step, f_fss_set_quotes_t * const set_quotes);
 #endif // _di_f_fss_set_quotes_increase_
 
 /**
@@ -618,7 +618,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_fss_sets_increase_
-  extern f_status_t f_fss_sets_increase(const uint16_t step, f_fss_sets_t * const sets);
+  extern f_status_t f_fss_sets_increase(const f_array_length_t step, f_fss_sets_t * const sets);
 #endif // _di_f_fss_sets_increase_
 
 /**
diff --git a/level_0/f_iki/c/iki.c b/level_0/f_iki/c/iki.c
index 58cc96d..ce3d5d1 100644
--- a/level_0/f_iki/c/iki.c
+++ b/level_0/f_iki/c/iki.c
@@ -52,14 +52,11 @@ extern "C" {
 #endif // _di_f_iki_object_partial_is_
 
 #ifndef _di_f_iki_read_
-  f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits) {
+  f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data) {
     #ifndef _di_level_0_parameter_checking_
       if (!buffer) return F_status_set_error(F_parameter);
       if (!range) return F_status_set_error(F_parameter);
-      if (!variable) return F_status_set_error(F_parameter);
-      if (!vocabulary) return F_status_set_error(F_parameter);
-      if (!content) return F_status_set_error(F_parameter);
-      if (!delimits) return F_status_set_error(F_parameter);
+      if (!data) return F_status_set_error(F_parameter);
     #endif // _di_level_0_parameter_checking_
 
     if (!buffer->used) {
@@ -98,7 +95,7 @@ extern "C" {
     f_string_range_t found_vocabulary = f_string_range_t_initialize;
     f_array_length_t found_content = 0;
     f_array_length_t vocabulary_slash_first = range->start;
-    const f_array_length_t delimits_used = delimits->used;
+    const f_array_length_t delimits_used = data->delimits.used;
 
     uint8_t quote = 0;
 
@@ -212,13 +209,13 @@ extern "C" {
           if (F_status_is_error(status)) break;
 
           if (range->start > range->stop) {
-            delimits->used = delimits_used;
+            data->delimits.used = delimits_used;
 
             return F_data_not_stop;
           }
 
           if (range->start >= buffer->used) {
-            delimits->used = delimits_used;
+            data->delimits.used = delimits_used;
 
             return F_data_not_eos;
           }
@@ -231,7 +228,7 @@ extern "C" {
       } // while
 
       if (F_status_is_error(status)) {
-        delimits->used = delimits_used;
+        data->delimits.used = delimits_used;
 
         return status;
       }
@@ -262,36 +259,37 @@ extern "C" {
 
             // This is a valid vocabulary name and content, but if it is delimited, save the delimit and ignore.
             if (vocabulary_delimited) {
-              status = f_array_lengths_increase(state.step_small, delimits);
+              status = f_array_lengths_increase(state.step_small, &data->delimits);
               if (F_status_is_error(status)) break;
 
-              delimits->array[delimits->used++] = vocabulary_slash_first;
+              data->delimits.array[data->delimits.used++] = vocabulary_slash_first;
 
               find_next = F_true;
               vocabulary_delimited = F_false;
               quote = 0;
 
               ++range->start;
+
               break;
             }
 
-            status = f_string_ranges_increase(state.step_small, variable);
+            status = f_string_ranges_increase(state.step_small, &data->variable);
             if (F_status_is_error(status)) break;
 
-            status = f_string_ranges_increase(state.step_small, vocabulary);
+            status = f_string_ranges_increase(state.step_small, &data->vocabulary);
             if (F_status_is_error(status)) break;
 
-            status = f_string_ranges_increase(state.step_small, content);
+            status = f_string_ranges_increase(state.step_small, &data->content);
             if (F_status_is_error(status)) break;
 
-            variable->array[variable->used].start = found_vocabulary.start;
-            variable->array[variable->used++].stop = range->start;
+            data->variable.array[data->variable.used].start = found_vocabulary.start;
+            data->variable.array[data->variable.used++].stop = range->start;
 
-            vocabulary->array[vocabulary->used].start = found_vocabulary.start;
-            vocabulary->array[vocabulary->used++].stop = found_vocabulary.stop;
+            data->vocabulary.array[data->vocabulary.used].start = found_vocabulary.start;
+            data->vocabulary.array[data->vocabulary.used++].stop = found_vocabulary.stop;
 
-            content->array[content->used].start = found_content;
-            content->array[content->used++].stop = range->start - 1;
+            data->content.array[data->content.used].start = found_content;
+            data->content.array[data->content.used++].stop = range->start - 1;
 
             if (++range->start > range->stop) {
               return F_none_stop;
@@ -324,7 +322,7 @@ extern "C" {
                   ++content_slash_delimits;
                 }
 
-                status = f_array_lengths_increase_by(content_slash_delimits, delimits);
+                status = f_array_lengths_increase_by(content_slash_delimits, &data->delimits);
                 if (F_status_is_error(status)) break;
 
                 content_range.start = content_slash_first;
@@ -333,7 +331,7 @@ extern "C" {
                 while (i < content_slash_delimits) {
 
                   if (buffer->string[content_range.start] == f_iki_syntax_slash_s.string[0]) {
-                    delimits->array[delimits->used++] = content_range.start;
+                    data->delimits.array[data->delimits.used++] = content_range.start;
                     ++i;
                   }
 
@@ -348,10 +346,10 @@ extern "C" {
 
                   // This is a valid vocabulary name and content, but if it is delimited, save the delimit and ignore.
                   if (vocabulary_delimited) {
-                    status = f_array_lengths_increase(state.step_small, delimits);
+                    status = f_array_lengths_increase(state.step_small, &data->delimits);
                     if (F_status_is_error(status)) break;
 
-                    delimits->array[delimits->used++] = vocabulary_slash_first;
+                    data->delimits.array[data->delimits.used++] = vocabulary_slash_first;
 
                     vocabulary_delimited = F_false;
                     quote = 0;
@@ -364,23 +362,23 @@ extern "C" {
                     found_vocabulary.start = range->start;
                   }
                   else {
-                    status = f_string_ranges_increase(state.step_small, variable);
+                    status = f_string_ranges_increase(state.step_small, &data->variable);
                     if (F_status_is_error(status)) break;
 
-                    status = f_string_ranges_increase(state.step_small, vocabulary);
+                    status = f_string_ranges_increase(state.step_small, &data->vocabulary);
                     if (F_status_is_error(status)) break;
 
-                    status = f_string_ranges_increase(state.step_small, content);
+                    status = f_string_ranges_increase(state.step_small, &data->content);
                     if (F_status_is_error(status)) break;
 
-                    variable->array[variable->used].start = found_vocabulary.start;
-                    variable->array[variable->used++].stop = range->start;
+                    data->variable.array[data->variable.used].start = found_vocabulary.start;
+                    data->variable.array[data->variable.used++].stop = range->start;
 
-                    vocabulary->array[vocabulary->used].start = found_vocabulary.start;
-                    vocabulary->array[vocabulary->used++].stop = found_vocabulary.stop;
+                    data->vocabulary.array[data->vocabulary.used].start = found_vocabulary.start;
+                    data->vocabulary.array[data->vocabulary.used++].stop = found_vocabulary.stop;
 
-                    content->array[content->used].start = found_content;
-                    content->array[content->used++].stop = range->start - 1;
+                    data->content.array[data->content.used].start = found_content;
+                    data->content.array[data->content.used++].stop = range->start - 1;
 
                     if (++range->start > range->stop) {
                       return F_none_stop;
@@ -397,9 +395,7 @@ extern "C" {
                 break;
               }
 
-              if (buffer->string[range->start] != f_iki_syntax_slash_s.string[0]) {
-                break;
-              }
+              if (buffer->string[range->start] != f_iki_syntax_slash_s.string[0]) break;
 
               ++content_slash_total;
 
@@ -420,7 +416,7 @@ extern "C" {
       }
 
       if (F_status_is_error(status)) {
-        delimits->used = delimits_used;
+        data->delimits.used = delimits_used;
 
         return status;
       }
diff --git a/level_0/f_iki/c/iki.h b/level_0/f_iki/c/iki.h
index f087342..9e4ea02 100644
--- a/level_0/f_iki/c/iki.h
+++ b/level_0/f_iki/c/iki.h
@@ -136,14 +136,8 @@ extern "C" {
  *   The start location will be updated as the buffer is being processed.
  *   The start location will represent where the read stopped on return.
  *   A start location past the stop location or buffer used means that the entire range was processed.
- * @param variable
- *   The entire vocabulary name, content, and syntax.
- * @param vocabulary
- *   The vocabulary name list to store the found vocabulary name.
- * @param content
- *   The content list to store the content associated with the found vocabulary name.
- * @param delimits
- *   A delimits array representing where delimits exist within the buffer.
+ * @param data
+ *   The IKI variable data.
  *
  * @return
  *   F_none on success and an IKI vocabulary name was found.
@@ -159,7 +153,7 @@ extern "C" {
  *   F_string_too_large (with error bit) if a string length is too large to store in the buffer.
  */
 #ifndef _di_f_iki_read_
-  extern f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits);
+  extern f_status_t f_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data);
 #endif // _di_f_iki_read_
 
 #ifdef __cplusplus
diff --git a/level_0/f_iki/c/iki/common.c b/level_0/f_iki/c/iki/common.c
index 5af824e..2bfc0cc 100644
--- a/level_0/f_iki/c/iki/common.c
+++ b/level_0/f_iki/c/iki/common.c
@@ -1,4 +1,5 @@
 #include "../iki.h"
+#include "../private-iki.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -12,7 +13,7 @@ extern "C" {
   const f_string_static_t f_iki_syntax_slash_s = macro_f_string_static_t_initialize(F_iki_syntax_slash_s, 0, F_iki_syntax_slash_s_length);
 #endif //_di_f_iki_syntax_
 
-#ifndef _di_iki_vocabulary_0001_s_
+#ifndef _di_f_iki_vocabulary_0001_s_
   const f_string_static_t f_iki_vocabulary_0001_address_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_address_s, 0, F_iki_vocabulary_0001_address_s_length);
   const f_string_static_t f_iki_vocabulary_0001_code_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_code_s, 0, F_iki_vocabulary_0001_code_s_length);
   const f_string_static_t f_iki_vocabulary_0001_email_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_email_s, 0, F_iki_vocabulary_0001_email_s_length);
@@ -23,13 +24,185 @@ extern "C" {
   const f_string_static_t f_iki_vocabulary_0001_url_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_url_s, 0, F_iki_vocabulary_0001_url_s_length);
   const f_string_static_t f_iki_vocabulary_0001_urn_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_urn_s, 0, F_iki_vocabulary_0001_urn_s_length);
   const f_string_static_t f_iki_vocabulary_0001_variable_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0001_variable_s, 0, F_iki_vocabulary_0001_variable_s_length);
-#endif // _di_iki_vocabulary_0001_s_
+#endif // _di_f_iki_vocabulary_0001_s_
 
-#ifndef _di_iki_vocabulary_0002_s_
+#ifndef _di_f_iki_vocabulary_0002_s_
   const f_string_static_t f_iki_vocabulary_0002_context_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0002_context_s, 0, F_iki_vocabulary_0002_context_s_length);
   const f_string_static_t f_iki_vocabulary_0002_define_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0002_define_s, 0, F_iki_vocabulary_0002_define_s_length);
   const f_string_static_t f_iki_vocabulary_0002_parameter_s = macro_f_string_static_t_initialize(F_iki_vocabulary_0002_parameter_s, 0, F_iki_vocabulary_0002_parameter_s_length);
-#endif // _di_iki_vocabulary_0002_s_
+#endif // _di_f_iki_vocabulary_0002_s_
+
+#ifndef _di_f_iki_data_delete_
+  f_status_t f_iki_data_delete(f_iki_data_t *data) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!data) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    f_status_t status = f_string_ranges_resize(0, &data->content);
+    if (F_status_is_error(status)) return status;
+
+    status = f_array_lengths_resize(0, &data->delimits);
+    if (F_status_is_error(status)) return status;
+
+    status = f_string_ranges_resize(0, &data->variable);
+    if (F_status_is_error(status)) return status;
+
+    status = f_string_ranges_resize(0, &data->vocabulary);
+    if (F_status_is_error(status)) return status;
+
+    return F_none;
+  }
+#endif // _di_f_iki_data_delete_
+
+#ifndef _di_f_iki_data_destroy_
+  f_status_t f_iki_data_destroy(f_iki_data_t *data) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!data) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    f_status_t status = f_string_ranges_adjust(0, &data->content);
+    if (F_status_is_error(status)) return status;
+
+    status = f_array_lengths_adjust(0, &data->delimits);
+    if (F_status_is_error(status)) return status;
+
+    status = f_string_ranges_adjust(0, &data->variable);
+    if (F_status_is_error(status)) return status;
+
+    status = f_string_ranges_adjust(0, &data->vocabulary);
+    if (F_status_is_error(status)) return status;
+
+    return F_none;
+  }
+#endif // _di_f_iki_data_destroy_
+
+#ifndef _di_f_iki_datas_adjust_
+  f_status_t f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!datas) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    return private_f_iki_datas_adjust(length, datas);
+  }
+#endif // _di_f_iki_datas_adjust_
+
+#ifndef _di_f_iki_datas_append_
+  f_status_t f_iki_datas_append(const f_iki_datas_t source, f_iki_datas_t *destination) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!destination) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    if (!source.used) return F_data_not;
+
+    f_status_t status = F_none;
+
+    if (destination->used + source.used > destination->size) {
+      status = private_f_iki_datas_resize(destination->used + source.used, destination);
+      if (F_status_is_error(status)) return status;
+    }
+
+    for (f_array_length_t i = 0; i < source.used; ++i, ++destination->used) {
+
+      status = f_string_ranges_append(source.array[i].content, &destination->array[destination->used].content);
+      if (F_status_is_error(status)) return status;
+
+      status = f_array_lengths_append(source.array[i].delimits, &destination->array[destination->used].delimits);
+      if (F_status_is_error(status)) return status;
+
+      status = f_string_ranges_append(source.array[i].variable, &destination->array[destination->used].variable);
+      if (F_status_is_error(status)) return status;
+
+      status = f_string_ranges_append(source.array[i].vocabulary, &destination->array[destination->used].vocabulary);
+      if (F_status_is_error(status)) return status;
+    } // for
+
+    return F_none;
+  }
+#endif // _di_f_iki_datas_append_
+
+#ifndef _di_f_iki_datas_decimate_by_
+  f_status_t f_iki_datas_decimate_by(const f_array_length_t amount, f_iki_datas_t *datas) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!amount) return F_status_set_error(F_parameter);
+      if (!datas) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    if (datas->size - amount > 0) {
+      return private_f_iki_datas_adjust(datas->size - amount, datas);
+    }
+
+    return private_f_iki_datas_adjust(0, datas);
+  }
+#endif // _di_f_iki_datas_decimate_by_
+
+#ifndef _di_f_iki_datas_decrease_by_
+  f_status_t f_iki_datas_decrease_by(const f_array_length_t amount, f_iki_datas_t *datas) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!amount) return F_status_set_error(F_parameter);
+      if (!datas) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    if (datas->size - amount > 0) {
+      return private_f_iki_datas_resize(datas->size - amount, datas);
+    }
+
+    return private_f_iki_datas_resize(0, datas);
+  }
+#endif // _di_f_iki_datas_decrease_by_
+
+#ifndef _di_f_iki_datas_increase_
+  f_status_t f_iki_datas_increase(const f_array_length_t step, f_iki_datas_t *datas) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!step) return F_status_set_error(F_parameter);
+      if (!datas) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    if (datas->used + 1 > datas->size) {
+      f_array_length_t size = datas->used + step;
+
+      if (size > F_array_length_t_size_d) {
+        if (datas->used + 1 > F_array_length_t_size_d) {
+          return F_status_set_error(F_array_too_large);
+        }
+
+        size = F_array_length_t_size_d;
+      }
+
+      return private_f_iki_datas_resize(size, datas);
+    }
+
+    return F_data_not;
+  }
+#endif // _di_f_iki_datas_increase_
+
+#ifndef _di_f_iki_datas_increase_by_
+  f_status_t f_iki_datas_increase_by(const f_array_length_t amount, f_iki_datas_t *datas) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!amount) return F_status_set_error(F_parameter);
+      if (!datas) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    if (datas->used + amount > datas->size) {
+      if (datas->used + amount > F_array_length_t_size_d) {
+        return F_status_set_error(F_array_too_large);
+      }
+
+      return private_f_iki_datas_resize(datas->used + amount, datas);
+    }
+
+    return F_data_not;
+  }
+#endif // _di_f_iki_datas_increase_by_
+
+#ifndef _di_f_iki_datas_resize_
+  f_status_t f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas) {
+    #ifndef _di_level_0_parameter_checking_
+      if (!datas) return F_status_set_error(F_parameter);
+    #endif // _di_level_0_parameter_checking_
+
+    return private_f_iki_datas_resize(length, datas);
+  }
+#endif // _di_f_iki_datas_resize_
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/level_0/f_iki/c/iki/common.h b/level_0/f_iki/c/iki/common.h
index 3f74b0f..387f00b 100644
--- a/level_0/f_iki/c/iki/common.h
+++ b/level_0/f_iki/c/iki/common.h
@@ -39,7 +39,7 @@ extern "C" {
   extern const f_string_static_t f_iki_syntax_slash_s;
 #endif //_di_f_iki_syntax_
 
-#ifndef _di_iki_vocabulary_0001_
+#ifndef _di_f_iki_vocabulary_0001_
   #define F_iki_vocabulary_0001_address_s  "address"
   #define F_iki_vocabulary_0001_code_s     "code"
   #define F_iki_vocabulary_0001_email_s    "email"
@@ -72,9 +72,9 @@ extern "C" {
   extern const f_string_static_t f_iki_vocabulary_0001_url_s;
   extern const f_string_static_t f_iki_vocabulary_0001_urn_s;
   extern const f_string_static_t f_iki_vocabulary_0001_variable_s;
-#endif // _di_iki_vocabulary_0001_
+#endif // _di_f_iki_vocabulary_0001_
 
-#ifndef _di_iki_vocabulary_0002_
+#ifndef _di_f_iki_vocabulary_0002_
   #define F_iki_vocabulary_0002_context_s   "context"
   #define F_iki_vocabulary_0002_define_s    "define"
   #define F_iki_vocabulary_0002_parameter_s "parameter"
@@ -86,9 +86,7 @@ extern "C" {
   extern const f_string_static_t f_iki_vocabulary_0002_context_s;
   extern const f_string_static_t f_iki_vocabulary_0002_define_s;
   extern const f_string_static_t f_iki_vocabulary_0002_parameter_s;
-#endif // _di_iki_vocabulary_0002_
-
-// @todo consider IKI-0003 = vocabulary based on context from HTML5 and accessibility-related?
+#endif // _di_f_iki_vocabulary_0002_
 
 /**
  * Designate an iki delimit location.
@@ -157,7 +155,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_iki_variable_t_
+#ifndef _di_f_iki_variable_t_
   typedef f_string_ranges_t f_iki_variable_t;
 
   #define f_iki_variable_t_initialize f_string_ranges_t_initialize
@@ -170,7 +168,7 @@ extern "C" {
   #define macro_f_iki_variable_t_delete_simple(variable)  macro_f_string_ranges_t_delete_simple(variable)
   #define macro_f_iki_variable_t_destroy_simple(variable) macro_f_string_ranges_t_destroy_simple(variable)
 
-#endif // _di_iki_variable_t_
+#endif // _di_f_iki_variable_t_
 
 /**
  * This holds an array of string ranges that represent the vocabulary names.
@@ -179,7 +177,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_iki_vocabulary_t_
+#ifndef _di_f_iki_vocabulary_t_
   typedef f_string_ranges_t f_iki_vocabulary_t;
 
   #define f_iki_vocabulary_t_initialize f_string_ranges_t_initialize
@@ -191,7 +189,7 @@ extern "C" {
 
   #define macro_f_iki_vocabulary_t_delete_simple(vocabulary)  macro_f_string_ranges_t_delete_simple(vocabulary)
   #define macro_f_iki_vocabulary_t_destroy_simple(vocabulary) macro_f_string_ranges_t_destroy_simple(vocabulary)
-#endif // _di_iki_vocabulary_t_
+#endif // _di_f_iki_vocabulary_t_
 
 /**
  * This holds an array of f_iki_vocabulary_t.
@@ -200,7 +198,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_iki_vocabularys_t_
+#ifndef _di_f_iki_vocabularys_t_
   typedef f_string_rangess_t f_iki_vocabularys_t;
 
   #define f_iki_vocabularys_t_initialize f_string_rangess_t_initialize
@@ -212,7 +210,7 @@ extern "C" {
 
   #define macro_f_iki_vocabularys_t_delete_simple(content)  macro_f_string_rangess_t_delete_simple(content)
   #define macro_f_iki_vocabularys_t_destroy_simple(content) macro_f_string_rangess_t_destroy_simple(content)
-#endif // _di_iki_vocabularys_t_
+#endif // _di_f_iki_vocabularys_t_
 
 /**
  * This holds an array of string ranges that represent the content.
@@ -223,7 +221,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_iki_content_t_
+#ifndef _di_f_iki_content_t_
   typedef f_string_ranges_t f_iki_content_t;
 
   #define f_iki_content_t_initialize f_string_ranges_t_initialize
@@ -235,7 +233,7 @@ extern "C" {
 
   #define macro_f_iki_content_t_delete_simple(content)  macro_f_string_ranges_t_delete_simple(content)
   #define macro_f_iki_content_t_destroy_simple(content) macro_f_string_ranges_t_destroy_simple(content)
-#endif // _di_iki_content_t_
+#endif // _di_f_iki_content_t_
 
 /**
  * This holds an array of f_iki_content_t.
@@ -244,7 +242,7 @@ extern "C" {
  * size:  Total amount of allocated space.
  * used:  Total number of allocated spaces used.
  */
-#ifndef _di_iki_contents_t_
+#ifndef _di_f_iki_contents_t_
   typedef f_string_rangess_t f_iki_contents_t;
 
   #define f_iki_contents_t_initialize f_string_rangess_t_initialize
@@ -256,7 +254,71 @@ extern "C" {
 
   #define macro_f_iki_contents_t_delete_simple(content)  macro_f_string_rangess_t_delete_simple(content)
   #define macro_f_iki_contents_t_destroy_simple(content) macro_f_string_rangess_t_destroy_simple(content)
-#endif // _di_iki_contents_t_
+#endif // _di_f_iki_contents_t_
+
+/**
+ * This containg all of the IKI data.
+ *
+ * content:    A set of ranges representing the content list to store the content associated with the found vocabulary name.
+ * delimits:   A delimits array representing where delimits exist within the buffer.
+ * variable:   A set of ranges representing the entire vocabulary name, content, and syntax.
+ * vocabulary: A set of ranges representing the vocabulary name list to store the found vocabulary name.
+ */
+#ifndef _di_f_iki_data_t_
+  typedef struct {
+    f_iki_content_t content;
+    f_iki_delimits_t delimits;
+    f_iki_variable_t variable;
+    f_iki_vocabulary_t vocabulary;
+  } f_iki_data_t;
+
+  #define f_iki_data_t_initialize { \
+    f_iki_content_t_initialize, \
+    f_iki_delimits_t_initialize, \
+    f_iki_variable_t_initialize, \
+    f_iki_vocabulary_t_initialize, \
+  }
+
+  #define macro_f_iki_data_t_clear(data) \
+    f_iki_content_t_clear(data.content) \
+    f_iki_delimits_t_clear(data.delimits) \
+    f_iki_variable_t_clear(data.variable) \
+    f_iki_vocabulary_t_clear(data.vocabulary)
+
+  #define macro_f_iki_data_t_delete_simple(data)  status = f_iki_data_delete(data);
+  #define macro_f_iki_data_t_destroy_simple(data) status = f_iki_data_destroy(data);
+#endif // _di_f_iki_data_t_
+
+/**
+ * An array of f_iki_data_t.
+ *
+ * array: The array of fss quotes.
+ * size:  Total amount of allocated space.
+ * used:  Total number of allocated spaces used.
+ */
+#ifndef _di_f_iki_datas_t_
+  typedef struct {
+    f_iki_data_t *array;
+
+    f_array_length_t size;
+    f_array_length_t used;
+  } f_iki_datas_t;
+
+  #define f_fss_iki_datas_t_initialize { 0, 0, 0 }
+
+  #define macro_f_fss_iki_datas_t_clear(datas) macro_f_memory_structure_clear(datas)
+
+  #define macro_f_fss_iki_datas_t_resize(status, datas, length) status = f_iki_datas_resize(length, &datas);
+  #define macro_f_fss_iki_datas_t_adjust(status, datas, length) status = f_iki_datas_adjust(length, &datas);
+
+  #define macro_f_fss_iki_datas_t_delete_simple(datas)  status = f_iki_datas_resize(0, &datas);
+  #define macro_f_fss_iki_datas_t_destroy_simple(datas) status = f_iki_datas_adjust(0, &datas);
+
+  #define macro_f_fss_iki_datas_t_increase(status, step, datas)      status = f_iki_datas_increase(step, &datas);
+  #define macro_f_fss_iki_datas_t_increase_by(status, datas, amount) status = f_iki_datas_increase_by(amount, &datas);
+  #define macro_f_fss_iki_datas_t_decrease_by(status, datas, amount) status = f_iki_datas_decrease_by(amount, &datas);
+  #define macro_f_fss_iki_datas_t_decimate_by(status, datas, amount) status = f_iki_datas_decimate_by(amount, &datas);
+#endif // _di_f_iki_datas_t_
 
 /**
  * Provide a default allocation step.
@@ -267,6 +329,202 @@ extern "C" {
   #define F_iki_default_allocation_step_d 4
 #endif // _di_f_iki_default_allocation_step_
 
+/**
+ * Delete the IKI data.
+ *
+ * @param data
+ *   The IKI data to delete.
+ *
+ * @return
+ *   F_none on success.
+ *
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_array_lengths_resize().
+ *   Errors (with error bit) from: f_string_ranges_resize().
+ *
+ * @see f_array_lengths_resize()
+ * @see f_string_ranges_resize()
+ */
+#ifndef _di_f_iki_data_delete_
+  extern f_status_t f_iki_data_delete(f_iki_data_t *data);
+#endif // _di_f_iki_data_delete_
+
+/**
+ * Destroy the IKI data.
+ *
+ * @param data
+ *   The IKI data to destroy.
+ *
+ * @return
+ *   F_none on success.
+ *
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_array_lengths_adjust().
+ *   Errors (with error bit) from: f_string_ranges_adjust().
+ *
+ * @see f_array_lengths_adjust()
+ * @see f_string_ranges_adjust()
+ */
+#ifndef _di_f_iki_data_destroy_
+  extern f_status_t f_iki_data_destroy(f_iki_data_t *data);
+#endif // _di_f_iki_data_destroy_
+
+/**
+ * Resize the string lengths array.
+ *
+ * @param length
+ *   The new size to use.
+ * @param lengths
+ *   The string lengths array to resize.
+ *
+ * @return
+ *   F_none on success.
+ *
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_iki_datas_adjust_
+  extern f_status_t f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas);
+#endif // _di_f_iki_datas_adjust_
+
+/**
+ * Append the source lengths onto the destination.
+ *
+ * @param source
+ *   The source lengths to append.
+ * @param destination
+ *   The destination lengths the source is appended onto.
+ *
+ * @return
+ *   F_none on success.
+ *   F_data_not on success, but there is nothing to append (size == 0).
+ *
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_iki_datas_append_
+  extern f_status_t f_iki_datas_append(const f_iki_datas_t source, f_iki_datas_t *destination);
+#endif // _di_f_iki_datas_append_
+
+/**
+ * Resize the string lengths array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ *   A positive number representing how much to decimate the size by.
+ * @param lengths
+ *   The string lengths array to resize.
+ *
+ * @return
+ *   F_none on success.
+ *
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_memory_adjust().
+ */
+#ifndef _di_f_iki_datas_decimate_by_
+  extern f_status_t f_iki_datas_decimate_by(const f_array_length_t amount, f_iki_datas_t *datas);
+#endif // _di_f_iki_datas_decimate_by_
+
+/**
+ * Resize the string lengths array to a smaller size.
+ *
+ * This will resize making the array smaller based on (size - given length).
+ * If the given length is too small, then the resize will fail.
+ * This will not shrink the size to les than 0.
+ *
+ * @param amount
+ *   A positive number representing how much to decrease the size by.
+ * @param lengths
+ *   The string lengths array to resize.
+ *
+ * @return
+ *   F_none on success.
+ *
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_iki_datas_decrease_by_
+  extern f_status_t f_iki_datas_decrease_by(const f_array_length_t amount, f_iki_datas_t *datas);
+#endif // _di_f_iki_datas_decrease_by_
+
+/**
+ * Increase the size of the string lengths array, but only if necesary.
+ *
+ * If the given length is too large for the buffer, then attempt to set max buffer size (F_array_length_t_size_d).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param step
+ *   The allocation step to use.
+ *   Must be greater than 0.
+ * @param lengths
+ *   The string lengths array to resize.
+ *
+ * @return
+ *   F_none on success.
+ *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ *   F_array_too_large (with error bit) if the new array length is too large.
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_iki_datas_increase_
+  extern f_status_t f_iki_datas_increase(const f_array_length_t step, f_iki_datas_t *datas);
+#endif // _di_f_iki_datas_increase_
+
+/**
+ * Resize the string lengths array to a larger size.
+ *
+ * This will resize making the string larger based on the given length.
+ * If the given length is too large for the buffer, then attempt to set max buffer size (F_array_length_t_size_d).
+ * If already set to the maximum buffer size, then the resize will fail.
+ *
+ * @param amount
+ *   A positive number representing how much to increase the size by.
+ * @param lengths
+ *   The string lengths array to resize.
+ *
+ * @return
+ *   F_none on success.
+ *   F_data_not on success, but there is no reason to increase size (used + amount <= size).
+ *
+ *   F_array_too_large (with error bit) if the new array length is too large.
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_iki_datas_increase_by_
+  extern f_status_t f_iki_datas_increase_by(const f_array_length_t amount, f_iki_datas_t *datas);
+#endif // _di_f_iki_datas_increase_by_
+
+/**
+ * Resize the string lengths array.
+ *
+ * @param length
+ *   The new size to use.
+ * @param lengths
+ *   The string lengths array to adjust.
+ *
+ * @return
+ *   F_none on success.
+ *
+ *   F_parameter (with error bit) if a parameter is invalid.
+ *
+ *   Errors (with error bit) from: f_memory_resize().
+ */
+#ifndef _di_f_iki_datas_resize_
+  extern f_status_t f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas);
+#endif // _di_f_iki_datas_resize_
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_iki/c/private-iki.c b/level_0/f_iki/c/private-iki.c
index 8970b49..0a4727e 100644
--- a/level_0/f_iki/c/private-iki.c
+++ b/level_0/f_iki/c/private-iki.c
@@ -5,6 +5,82 @@
 extern "C" {
 #endif
 
+#if !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_)
+  f_status_t private_f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas) {
+
+    if (datas->used + length > F_array_length_t_size_d) {
+      return F_status_set_error(F_array_too_large);
+    }
+
+    f_status_t status = F_none;
+
+    for (f_array_length_t i = length; i < datas->size; ++i) {
+
+      status = f_string_ranges_adjust(0, &datas->array[i].content);
+      if (F_status_is_error(status)) return status;
+
+      status = f_array_lengths_adjust(0, &datas->array[i].delimits);
+      if (F_status_is_error(status)) return status;
+
+      status = f_string_ranges_adjust(0, &datas->array[i].variable);
+      if (F_status_is_error(status)) return status;
+
+      status = f_string_ranges_adjust(0, &datas->array[i].vocabulary);
+      if (F_status_is_error(status)) return status;
+    } // for
+
+    status = f_memory_adjust(datas->size, length, sizeof(f_iki_data_t), (void **) & datas->array);
+
+    if (F_status_is_error_not(status)) {
+      datas->size = length;
+
+      if (datas->used > datas->size) {
+        datas->used = length;
+      }
+    }
+
+    return status;
+  }
+#endif // !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_)
+
+#if !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_)
+  f_status_t private_f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas) {
+
+    if (datas->used + length > F_array_length_t_size_d) {
+      return F_status_set_error(F_array_too_large);
+    }
+
+    f_status_t status = F_none;
+
+    for (f_array_length_t i = length; i < datas->size; ++i) {
+
+      status = f_string_ranges_resize(0, &datas->array[i].content);
+      if (F_status_is_error(status)) return status;
+
+      status = f_array_lengths_resize(0, &datas->array[i].delimits);
+      if (F_status_is_error(status)) return status;
+
+      status = f_string_ranges_resize(0, &datas->array[i].variable);
+      if (F_status_is_error(status)) return status;
+
+      status = f_string_ranges_resize(0, &datas->array[i].vocabulary);
+      if (F_status_is_error(status)) return status;
+    } // for
+
+    status = f_memory_resize(datas->size, length, sizeof(f_iki_data_t), (void **) & datas->array);
+
+    if (F_status_is_error_not(status)) {
+      datas->size = length;
+
+      if (datas->used > datas->size) {
+        datas->used = length;
+      }
+    }
+
+    return status;
+  }
+#endif // !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_)
+
 #if !defined(_di_f_iki_read_)
   f_status_t private_f_iki_seek_special(const f_string_static_t buffer, f_string_range_t * const range) {
 
diff --git a/level_0/f_iki/c/private-iki.h b/level_0/f_iki/c/private-iki.h
index b98ab16..24c2664 100644
--- a/level_0/f_iki/c/private-iki.h
+++ b/level_0/f_iki/c/private-iki.h
@@ -16,6 +16,58 @@ extern "C" {
 #endif
 
 /**
+ * Private implementation for resizing the iki_datas array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ *   The length to adjust to.
+ * @param datas
+ *   The IKI datas array to adjust.
+ *
+ * @return
+ *   F_none on success.
+ *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ *   Errors (with error bit) from: f_array_lengths_adjust().
+ *   Errors (with error bit) from: f_memory_adjust().
+ *   Errors (with error bit) from: f_string_ranges_adjust().
+ *
+ * @see f_array_lengths_adjust()
+ * @see f_memory_adjust()
+ * @see f_string_ranges_adjust()
+ */
+#if !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_)
+  extern f_status_t private_f_iki_datas_adjust(const f_array_length_t length, f_iki_datas_t *datas) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_iki_datas_adjust_) || !defined(_di_f_iki_datas_decimate_by_)
+
+/**
+ * Private implementation for resizing the iki_datas array.
+ *
+ * Intended to be shared to each of the different implementation variations.
+ *
+ * @param length
+ *   The length to adjust to.
+ * @param datas
+ *   The IKI datas array to adjust.
+ *
+ * @return
+ *   F_none on success.
+ *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
+ *
+ *   Errors (with error bit) from: f_array_lengths_resize().
+ *   Errors (with error bit) from: f_memory_resize().
+ *   Errors (with error bit) from: f_string_ranges_resize().
+ *
+ * @see f_array_lengths_resize()
+ * @see f_memory_resize()
+ * @see f_string_ranges_resize()
+ */
+#if !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_)
+  extern f_status_t private_f_iki_datas_resize(const f_array_length_t length, f_iki_datas_t *datas) F_attribute_visibility_internal_d;
+#endif // !defined(_di_f_iki_datas_append_) || !defined(_di_f_iki_datas_decrease_by_) || !defined(_di_f_iki_datas_increase_) || !defined(_di_f_iki_datas_increase_by_) || !defined(_di_f_iki_datas_resize_)
+
+/**
  * Private implementation of f_iki_content_partial_is().
  *
  * Intended to be shared to each of the different implementation variations.
diff --git a/level_0/f_memory/c/memory/structure.c b/level_0/f_memory/c/memory/structure.c
index c617b78..22dc263 100644
--- a/level_0/f_memory/c/memory/structure.c
+++ b/level_0/f_memory/c/memory/structure.c
@@ -53,7 +53,7 @@ extern "C" {
 #endif // _di_f_memory_structure_decrease_by_
 
 #ifndef _di_f_memory_structure_increase_
-  f_status_t f_memory_structure_increase(const uint16_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size) {
+  f_status_t f_memory_structure_increase(const f_array_length_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!type_size) return F_status_set_error(F_parameter);
diff --git a/level_0/f_memory/c/memory/structure.h b/level_0/f_memory/c/memory/structure.h
index 99bda4f..5600a57 100644
--- a/level_0/f_memory/c/memory/structure.h
+++ b/level_0/f_memory/c/memory/structure.h
@@ -142,7 +142,7 @@ extern "C" {
  * @see memset()
  */
 #ifndef _di_f_memory_structure_increase_
-  extern f_status_t f_memory_structure_increase(const uint16_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size);
+  extern f_status_t f_memory_structure_increase(const f_array_length_t step, const size_t type_size, void ** const structure, f_array_length_t * const used, f_array_length_t * const size);
 #endif // _di_f_memory_structure_increase_
 
 /**
diff --git a/level_0/f_string/c/string/dynamic.c b/level_0/f_string/c/string/dynamic.c
index 8ad6380..c0ed0bb 100644
--- a/level_0/f_string/c/string/dynamic.c
+++ b/level_0/f_string/c/string/dynamic.c
@@ -160,7 +160,7 @@ extern "C" {
 #endif // _di_f_string_dynamic_decrease_by_
 
 #ifndef _di_f_string_dynamic_increase_
-  f_status_t f_string_dynamic_increase(const uint16_t step, f_string_dynamic_t * const dynamic) {
+  f_status_t f_string_dynamic_increase(const f_array_length_t step, f_string_dynamic_t * const dynamic) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!dynamic) return F_status_set_error(F_parameter);
@@ -936,7 +936,7 @@ extern "C" {
 #endif // _di_f_string_dynamics_decrease_by_
 
 #ifndef _di_f_string_dynamics_increase_
-  f_status_t f_string_dynamics_increase(const uint16_t step, f_string_dynamics_t * const dynamics) {
+  f_status_t f_string_dynamics_increase(const f_array_length_t step, f_string_dynamics_t * const dynamics) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!dynamics) return F_status_set_error(F_parameter);
@@ -1043,7 +1043,7 @@ extern "C" {
 #endif // _di_f_string_dynamicss_decrease_by_
 
 #ifndef _di_f_string_dynamicss_increase_
-  f_status_t f_string_dynamicss_increase(const uint16_t step, f_string_dynamicss_t * const dynamicss) {
+  f_status_t f_string_dynamicss_increase(const f_array_length_t step, f_string_dynamicss_t * const dynamicss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!dynamicss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_string/c/string/dynamic.h b/level_0/f_string/c/string/dynamic.h
index ca50835..ffd5097 100644
--- a/level_0/f_string/c/string/dynamic.h
+++ b/level_0/f_string/c/string/dynamic.h
@@ -252,7 +252,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_dynamic_increase_
-  extern f_status_t f_string_dynamic_increase(const uint16_t step, f_string_dynamic_t * const dynamic);
+  extern f_status_t f_string_dynamic_increase(const f_array_length_t step, f_string_dynamic_t * const dynamic);
 #endif // _di_f_string_dynamic_increase_
 
 /**
@@ -1065,7 +1065,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_dynamics_increase_
-  extern f_status_t f_string_dynamics_increase(const uint16_t step, f_string_dynamics_t * const dynamics);
+  extern f_status_t f_string_dynamics_increase(const f_array_length_t step, f_string_dynamics_t * const dynamics);
 #endif // _di_f_string_dynamics_increase_
 
 /**
@@ -1222,7 +1222,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_dynamicss_increase_
-  extern f_status_t f_string_dynamicss_increase(const uint16_t step, f_string_dynamicss_t * const dynamicss);
+  extern f_status_t f_string_dynamicss_increase(const f_array_length_t step, f_string_dynamicss_t * const dynamicss);
 #endif // _di_f_string_dynamicss_increase_
 
 /**
diff --git a/level_0/f_string/c/string/map.c b/level_0/f_string/c/string/map.c
index 1aac93b..8e9eae3 100644
--- a/level_0/f_string/c/string/map.c
+++ b/level_0/f_string/c/string/map.c
@@ -79,7 +79,7 @@ extern "C" {
 #endif // _di_f_string_map_multis_decrease_by_
 
 #ifndef _di_f_string_map_multis_increase_
-  f_status_t f_string_map_multis_increase(const uint16_t step, f_string_map_multis_t * const map_multis) {
+  f_status_t f_string_map_multis_increase(const f_array_length_t step, f_string_map_multis_t * const map_multis) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!map_multis) return F_status_set_error(F_parameter);
@@ -200,7 +200,7 @@ extern "C" {
 #endif // _di_f_string_map_multiss_decrease_by_
 
 #ifndef _di_f_string_map_multiss_increase_
-  f_status_t f_string_map_multiss_increase(const uint16_t step, f_string_map_multiss_t * const map_multiss) {
+  f_status_t f_string_map_multiss_increase(const f_array_length_t step, f_string_map_multiss_t * const map_multiss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!map_multiss) return F_status_set_error(F_parameter);
@@ -306,7 +306,7 @@ extern "C" {
 #endif // _di_f_string_maps_decrease_by_
 
 #ifndef _di_f_string_maps_increase_
-  f_status_t f_string_maps_increase(const uint16_t step, f_string_maps_t * const maps) {
+  f_status_t f_string_maps_increase(const f_array_length_t step, f_string_maps_t * const maps) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!maps) return F_status_set_error(F_parameter);
@@ -429,7 +429,7 @@ extern "C" {
 #endif // _di_f_string_mapss_decrease_by_
 
 #ifndef _di_f_string_mapss_increase_
-  f_status_t f_string_mapss_increase(const uint16_t step, f_string_mapss_t * const mapss) {
+  f_status_t f_string_mapss_increase(const f_array_length_t step, f_string_mapss_t * const mapss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!mapss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_string/c/string/map.h b/level_0/f_string/c/string/map.h
index ee156de..452dd6b 100644
--- a/level_0/f_string/c/string/map.h
+++ b/level_0/f_string/c/string/map.h
@@ -302,7 +302,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_map_multis_increase_
-  extern f_status_t f_string_map_multis_increase(const uint16_t step, f_string_map_multis_t * const map_multis);
+  extern f_status_t f_string_map_multis_increase(const f_array_length_t step, f_string_map_multis_t * const map_multis);
 #endif // _di_f_string_map_multis_increase_
 
 /**
@@ -457,7 +457,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_maps_increase_
-  extern f_status_t f_string_maps_increase(const uint16_t step, f_string_maps_t * const maps);
+  extern f_status_t f_string_maps_increase(const f_array_length_t step, f_string_maps_t * const maps);
 #endif // _di_f_string_maps_increase_
 
 /**
@@ -612,7 +612,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_mapss_increase_
-  extern f_status_t f_string_mapss_increase(const uint16_t step, f_string_mapss_t * const mapss);
+  extern f_status_t f_string_mapss_increase(const f_array_length_t step, f_string_mapss_t * const mapss);
 #endif // _di_f_string_mapss_increase_
 
 /**
diff --git a/level_0/f_string/c/string/quantity.c b/level_0/f_string/c/string/quantity.c
index 3624b12..573a6d8 100644
--- a/level_0/f_string/c/string/quantity.c
+++ b/level_0/f_string/c/string/quantity.c
@@ -73,7 +73,7 @@ extern "C" {
 #endif // _di_f_string_quantitys_decrease_by_
 
 #ifndef _di_f_string_quantitys_increase_
-  f_status_t f_string_quantitys_increase(const uint16_t step, f_string_quantitys_t * const quantitys) {
+  f_status_t f_string_quantitys_increase(const f_array_length_t step, f_string_quantitys_t * const quantitys) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!quantitys) return F_status_set_error(F_parameter);
@@ -167,7 +167,7 @@ extern "C" {
 #endif // _di_f_string_quantityss_decrease_by_
 
 #ifndef _di_f_string_quantityss_increase_
-  f_status_t f_string_quantityss_increase(const uint16_t step, f_string_quantityss_t * const quantityss) {
+  f_status_t f_string_quantityss_increase(const f_array_length_t step, f_string_quantityss_t * const quantityss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!quantityss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_string/c/string/quantity.h b/level_0/f_string/c/string/quantity.h
index 19bce66..94346d0 100644
--- a/level_0/f_string/c/string/quantity.h
+++ b/level_0/f_string/c/string/quantity.h
@@ -205,7 +205,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_quantitys_increase_
-  extern f_status_t f_string_quantitys_increase(const uint16_t step, f_string_quantitys_t * const quantitys);
+  extern f_status_t f_string_quantitys_increase(const f_array_length_t step, f_string_quantitys_t * const quantitys);
 #endif // _di_f_string_quantitys_increase_
 
 /**
@@ -338,7 +338,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_quantityss_increase_
-  extern f_status_t f_string_quantityss_increase(const uint16_t step, f_string_quantityss_t * const quantityss);
+  extern f_status_t f_string_quantityss_increase(const f_array_length_t step, f_string_quantityss_t * const quantityss);
 #endif // _di_f_string_quantityss_increase_
 
 /**
diff --git a/level_0/f_string/c/string/range.c b/level_0/f_string/c/string/range.c
index 0cb06c9..79aa751 100644
--- a/level_0/f_string/c/string/range.c
+++ b/level_0/f_string/c/string/range.c
@@ -73,7 +73,7 @@ extern "C" {
 #endif // _di_f_string_ranges_decrease_by_
 
 #ifndef _di_f_string_ranges_increase_
-  f_status_t f_string_ranges_increase(const uint16_t step, f_string_ranges_t * const ranges) {
+  f_status_t f_string_ranges_increase(const f_array_length_t step, f_string_ranges_t * const ranges) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!ranges) return F_status_set_error(F_parameter);
@@ -167,7 +167,7 @@ extern "C" {
 #endif // _di_f_string_rangess_decrease_by_
 
 #ifndef _di_f_string_rangess_increase_
-  f_status_t f_string_rangess_increase(const uint16_t step, f_string_rangess_t * const rangess) {
+  f_status_t f_string_rangess_increase(const f_array_length_t step, f_string_rangess_t * const rangess) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!rangess) return F_status_set_error(F_parameter);
diff --git a/level_0/f_string/c/string/range.h b/level_0/f_string/c/string/range.h
index 82420d0..1ae647c 100644
--- a/level_0/f_string/c/string/range.h
+++ b/level_0/f_string/c/string/range.h
@@ -210,7 +210,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_ranges_increase_
-  extern f_status_t f_string_ranges_increase(const uint16_t step, f_string_ranges_t * const ranges);
+  extern f_status_t f_string_ranges_increase(const f_array_length_t step, f_string_ranges_t * const ranges);
 #endif // _di_f_string_ranges_increase_
 
 /**
@@ -344,7 +344,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_rangess_increase_
-  extern f_status_t f_string_rangess_increase(const uint16_t step, f_string_rangess_t * const rangess);
+  extern f_status_t f_string_rangess_increase(const f_array_length_t step, f_string_rangess_t * const rangess);
 #endif // _di_f_string_rangess_increase_
 
 /**
diff --git a/level_0/f_string/c/string/triple.c b/level_0/f_string/c/string/triple.c
index 497a581..eac16b8 100644
--- a/level_0/f_string/c/string/triple.c
+++ b/level_0/f_string/c/string/triple.c
@@ -89,7 +89,7 @@ extern "C" {
 #endif // _di_f_string_triples_decrease_by_
 
 #ifndef _di_f_string_triples_increase_
-  f_status_t f_string_triples_increase(const uint16_t step, f_string_triples_t * const triples) {
+  f_status_t f_string_triples_increase(const f_array_length_t step, f_string_triples_t * const triples) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!triples) return F_status_set_error(F_parameter);
diff --git a/level_0/f_string/c/string/triple.h b/level_0/f_string/c/string/triple.h
index 322cf29..b5c2570 100644
--- a/level_0/f_string/c/string/triple.h
+++ b/level_0/f_string/c/string/triple.h
@@ -192,7 +192,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_string_triples_increase_
-  extern f_status_t f_string_triples_increase(const uint16_t step, f_string_triples_t * const triples);
+  extern f_status_t f_string_triples_increase(const f_array_length_t step, f_string_triples_t * const triples);
 #endif // _di_f_string_triples_increase_
 
 /**
diff --git a/level_0/f_thread/c/thread.c b/level_0/f_thread/c/thread.c
index 6c49a98..2e58960 100644
--- a/level_0/f_thread/c/thread.c
+++ b/level_0/f_thread/c/thread.c
@@ -536,7 +536,7 @@ extern "C" {
 #endif // _di_f_thread_attributes_decrease_by_
 
 #ifndef _di_f_thread_attributes_increase_
-  f_status_t f_thread_attributes_increase(const uint16_t step, f_thread_attributes_t * const attributes) {
+  f_status_t f_thread_attributes_increase(const f_array_length_t step, f_thread_attributes_t * const attributes) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!attributes) return F_status_set_error(F_parameter);
@@ -688,7 +688,7 @@ extern "C" {
 #endif // _di_f_thread_barrier_attributes_decrease_by_
 
 #ifndef _di_f_thread_barrier_attributes_increase_
-  f_status_t f_thread_barrier_attributes_increase(const uint16_t step, f_thread_barrier_attributes_t * const attributes) {
+  f_status_t f_thread_barrier_attributes_increase(const f_array_length_t step, f_thread_barrier_attributes_t * const attributes) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!attributes) return F_status_set_error(F_parameter);
@@ -824,7 +824,7 @@ extern "C" {
 #endif // _di_f_thread_barriers_decrease_by_
 
 #ifndef _di_f_thread_barriers_increase_
-  f_status_t f_thread_barriers_increase(const uint16_t step, f_thread_barriers_t * const barriers) {
+  f_status_t f_thread_barriers_increase(const f_array_length_t step, f_thread_barriers_t * const barriers) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!barriers) return F_status_set_error(F_parameter);
@@ -1072,7 +1072,7 @@ extern "C" {
 #endif // _di_f_thread_condition_attributes_decrease_by_
 
 #ifndef _di_f_thread_condition_attributes_increase_
-  f_status_t f_thread_condition_attributes_increase(const uint16_t step, f_thread_condition_attributes_t * const attributes) {
+  f_status_t f_thread_condition_attributes_increase(const f_array_length_t step, f_thread_condition_attributes_t * const attributes) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!attributes) return F_status_set_error(F_parameter);
@@ -1278,7 +1278,7 @@ extern "C" {
 #endif // _di_f_thread_conditions_decrease_by_
 
 #ifndef _di_f_thread_conditions_increase_
-  f_status_t f_thread_conditions_increase(const uint16_t step, f_thread_conditions_t * const conditions) {
+  f_status_t f_thread_conditions_increase(const f_array_length_t step, f_thread_conditions_t * const conditions) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!conditions) return F_status_set_error(F_parameter);
@@ -1538,7 +1538,7 @@ extern "C" {
 #endif // _di_f_thread_keys_decrease_by_
 
 #ifndef _di_f_thread_keys_increase_
-  f_status_t f_thread_keys_increase(const uint16_t step, f_thread_keys_t * const keys) {
+  f_status_t f_thread_keys_increase(const f_array_length_t step, f_thread_keys_t * const keys) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!keys) return F_status_set_error(F_parameter);
@@ -1698,7 +1698,7 @@ extern "C" {
 #endif // _di_f_thread_lock_attributes_decrease_by_
 
 #ifndef _di_f_thread_lock_attributes_increase_
-  f_status_t f_thread_lock_attributes_increase(const uint16_t step, f_thread_lock_attributes_t * const attributes) {
+  f_status_t f_thread_lock_attributes_increase(const f_array_length_t step, f_thread_lock_attributes_t * const attributes) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!attributes) return F_status_set_error(F_parameter);
@@ -1945,7 +1945,7 @@ extern "C" {
 #endif // _di_f_thread_locks_decrease_by_
 
 #ifndef _di_f_thread_locks_increase_
-  f_status_t f_thread_locks_increase(const uint16_t step, f_thread_locks_t * const locks) {
+  f_status_t f_thread_locks_increase(const f_array_length_t step, f_thread_locks_t * const locks) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!locks) return F_status_set_error(F_parameter);
@@ -2217,7 +2217,7 @@ extern "C" {
 #endif // _di_f_thread_mutex_attributes_decrease_by_
 
 #ifndef _di_f_thread_mutex_attributes_increase_
-  f_status_t f_thread_mutex_attributes_increase(const uint16_t step, f_thread_mutex_attributes_t * const attributes) {
+  f_status_t f_thread_mutex_attributes_increase(const f_array_length_t step, f_thread_mutex_attributes_t * const attributes) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!attributes) return F_status_set_error(F_parameter);
@@ -2648,7 +2648,7 @@ extern "C" {
 #endif // _di_f_thread_mutexs_decrease_by_
 
 #ifndef _di_f_thread_mutexs_increase_
-  f_status_t f_thread_mutexs_increase(const uint16_t step, f_thread_mutexs_t * const mutexs) {
+  f_status_t f_thread_mutexs_increase(const f_array_length_t step, f_thread_mutexs_t * const mutexs) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!mutexs) return F_status_set_error(F_parameter);
@@ -2817,7 +2817,7 @@ extern "C" {
 #endif // _di_f_thread_semaphores_decrease_by_
 
 #ifndef _di_f_thread_semaphores_increase_
-  f_status_t f_thread_semaphores_increase(const uint16_t step, f_thread_semaphores_t * const semaphores) {
+  f_status_t f_thread_semaphores_increase(const f_array_length_t step, f_thread_semaphores_t * const semaphores) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!semaphores) return F_status_set_error(F_parameter);
@@ -2911,7 +2911,7 @@ extern "C" {
 #endif // _di_f_thread_sets_decrease_by_
 
 #ifndef _di_f_thread_sets_increase_
-  f_status_t f_thread_sets_increase(const uint16_t step, f_thread_sets_t * const sets) {
+  f_status_t f_thread_sets_increase(const f_array_length_t step, f_thread_sets_t * const sets) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!sets) return F_status_set_error(F_parameter);
@@ -3160,7 +3160,7 @@ extern "C" {
 #endif // _di_f_thread_spins_decrease_by_
 
 #ifndef _di_f_thread_spins_increase_
-  f_status_t f_thread_spins_increase(const uint16_t step, f_thread_spins_t * const spins) {
+  f_status_t f_thread_spins_increase(const f_array_length_t step, f_thread_spins_t * const spins) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!spins) return F_status_set_error(F_parameter);
diff --git a/level_0/f_thread/c/thread.h b/level_0/f_thread/c/thread.h
index f2c299c..86247ab 100644
--- a/level_0/f_thread/c/thread.h
+++ b/level_0/f_thread/c/thread.h
@@ -700,7 +700,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_attributes_increase_
-  extern f_status_t f_thread_attributes_increase(const uint16_t step, f_thread_attributes_t * const attributes);
+  extern f_status_t f_thread_attributes_increase(const f_array_length_t step, f_thread_attributes_t * const attributes);
 #endif // _di_f_thread_attributes_increase_
 
 /**
@@ -915,7 +915,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_barrier_attributes_increase_
-  extern f_status_t f_thread_barrier_attributes_increase(const uint16_t step, f_thread_barrier_attributes_t * const attributes);
+  extern f_status_t f_thread_barrier_attributes_increase(const f_array_length_t step, f_thread_barrier_attributes_t * const attributes);
 #endif // _di_f_thread_barrier_attributes_increase_
 
 /**
@@ -1108,7 +1108,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_barriers_increase_
-  extern f_status_t f_thread_barriers_increase(const uint16_t step, f_thread_barriers_t * const barriers);
+  extern f_status_t f_thread_barriers_increase(const f_array_length_t step, f_thread_barriers_t * const barriers);
 #endif // _di_f_thread_barriers_increase_
 
 /**
@@ -1453,7 +1453,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_condition_attributes_increase_
-  extern f_status_t f_thread_condition_attributes_increase(const uint16_t step, f_thread_condition_attributes_t * const attributes);
+  extern f_status_t f_thread_condition_attributes_increase(const f_array_length_t step, f_thread_condition_attributes_t * const attributes);
 #endif // _di_f_thread_condition_attributes_increase_
 
 /**
@@ -1722,7 +1722,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_conditions_increase_
-  extern f_status_t f_thread_conditions_increase(const uint16_t step, f_thread_conditions_t * const conditions);
+  extern f_status_t f_thread_conditions_increase(const f_array_length_t step, f_thread_conditions_t * const conditions);
 #endif // _di_f_thread_conditions_increase_
 
 /**
@@ -2099,7 +2099,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_keys_increase_
-  extern f_status_t f_thread_keys_increase(const uint16_t step, f_thread_keys_t * const keys);
+  extern f_status_t f_thread_keys_increase(const f_array_length_t step, f_thread_keys_t * const keys);
 #endif // _di_f_thread_keys_increase_
 
 /**
@@ -2315,7 +2315,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_lock_attributes_increase_
-  extern f_status_t f_thread_lock_attributes_increase(const uint16_t step, f_thread_lock_attributes_t * const attributes);
+  extern f_status_t f_thread_lock_attributes_increase(const f_array_length_t step, f_thread_lock_attributes_t * const attributes);
 #endif // _di_f_thread_lock_attributes_increase_
 
 /**
@@ -2640,7 +2640,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_locks_increase_
-  extern f_status_t f_thread_locks_increase(const uint16_t step, f_thread_locks_t * const locks);
+  extern f_status_t f_thread_locks_increase(const f_array_length_t step, f_thread_locks_t * const locks);
 #endif // _di_f_thread_locks_increase_
 
 /**
@@ -2981,7 +2981,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_mutex_attributes_increase_
-  extern f_status_t f_thread_mutex_attributes_increase(const uint16_t step, f_thread_mutex_attributes_t * const attributes);
+  extern f_status_t f_thread_mutex_attributes_increase(const f_array_length_t step, f_thread_mutex_attributes_t * const attributes);
 #endif // _di_f_thread_mutex_attributes_increase_
 
 /**
@@ -3309,7 +3309,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_mutexs_increase_
-  extern f_status_t f_thread_mutexs_increase(const uint16_t step, f_thread_mutexs_t * const mutexs);
+  extern f_status_t f_thread_mutexs_increase(const f_array_length_t step, f_thread_mutexs_t * const mutexs);
 #endif // _di_f_thread_mutexs_increase_
 
 /**
@@ -3785,7 +3785,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_semaphores_increase_
-  extern f_status_t f_thread_semaphores_increase(const uint16_t step, f_thread_semaphores_t * const semaphores);
+  extern f_status_t f_thread_semaphores_increase(const f_array_length_t step, f_thread_semaphores_t * const semaphores);
 #endif // _di_f_thread_semaphores_increase_
 
 /**
@@ -3913,7 +3913,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_sets_increase_
-  extern f_status_t f_thread_sets_increase(const uint16_t step, f_thread_sets_t * const sets);
+  extern f_status_t f_thread_sets_increase(const f_array_length_t step, f_thread_sets_t * const sets);
 #endif // _di_f_thread_sets_increase_
 
 /**
@@ -4233,7 +4233,7 @@ extern "C" {
  *   F_parameter (with error bit) if a parameter is invalid.
  */
 #ifndef _di_f_thread_spins_increase_
-  extern f_status_t f_thread_spins_increase(const uint16_t step, f_thread_spins_t * const spins);
+  extern f_status_t f_thread_spins_increase(const f_array_length_t step, f_thread_spins_t * const spins);
 #endif // _di_f_thread_spins_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/array_length.c b/level_0/f_type_array/c/type_array/array_length.c
index 0316dc1..7697406 100644
--- a/level_0/f_type_array/c/type_array/array_length.c
+++ b/level_0/f_type_array/c/type_array/array_length.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_array_lengths_decrease_by_
 
 #ifndef _di_f_array_lengths_increase_
-  f_status_t f_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths) {
+  f_status_t f_array_lengths_increase(const f_array_length_t step, f_array_lengths_t *lengths) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!lengths) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_array_lengthss_decrease_by_
 
 #ifndef _di_f_array_lengthss_increase_
-  f_status_t f_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss) {
+  f_status_t f_array_lengthss_increase(const f_array_length_t step, f_array_lengthss_t *lengthss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!lengthss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/array_length.h b/level_0/f_type_array/c/type_array/array_length.h
index b735f62..013182d 100644
--- a/level_0/f_type_array/c/type_array/array_length.h
+++ b/level_0/f_type_array/c/type_array/array_length.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_array_lengths_increase_
-  extern f_status_t f_array_lengths_increase(const uint16_t step, f_array_lengths_t *lengths);
+  extern f_status_t f_array_lengths_increase(const f_array_length_t step, f_array_lengths_t *lengths);
 #endif // _di_f_array_lengths_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_array_lengthss_increase_
-  extern f_status_t f_array_lengthss_increase(const uint16_t step, f_array_lengthss_t *lengthss);
+  extern f_status_t f_array_lengthss_increase(const f_array_length_t step, f_array_lengthss_t *lengthss);
 #endif // _di_f_array_lengthss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/cell.c b/level_0/f_type_array/c/type_array/cell.c
index d47f130..75938dd 100644
--- a/level_0/f_type_array/c/type_array/cell.c
+++ b/level_0/f_type_array/c/type_array/cell.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_cells_decrease_by_
 
 #ifndef _di_f_cells_increase_
-  f_status_t f_cells_increase(const uint16_t step, f_cells_t *cells) {
+  f_status_t f_cells_increase(const f_array_length_t step, f_cells_t *cells) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!cells) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_cellss_decrease_by_
 
 #ifndef _di_f_cellss_increase_
-  f_status_t f_cellss_increase(const uint16_t step, f_cellss_t *cellss) {
+  f_status_t f_cellss_increase(const f_array_length_t step, f_cellss_t *cellss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!cellss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/cell.h b/level_0/f_type_array/c/type_array/cell.h
index 16b7232..8323e63 100644
--- a/level_0/f_type_array/c/type_array/cell.h
+++ b/level_0/f_type_array/c/type_array/cell.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_cells_increase_
-  extern f_status_t f_cells_increase(const uint16_t step, f_cells_t *cells);
+  extern f_status_t f_cells_increase(const f_array_length_t step, f_cells_t *cells);
 #endif // _di_f_cells_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_cellss_increase_
-  extern f_status_t f_cellss_increase(const uint16_t step, f_cellss_t *cellss);
+  extern f_status_t f_cellss_increase(const f_array_length_t step, f_cellss_t *cellss);
 #endif // _di_f_cellss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/fll_id.c b/level_0/f_type_array/c/type_array/fll_id.c
index fa5c6c5..fa3cf8b 100644
--- a/level_0/f_type_array/c/type_array/fll_id.c
+++ b/level_0/f_type_array/c/type_array/fll_id.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_fll_ids_decrease_by_
 
 #ifndef _di_f_fll_ids_increase_
-  f_status_t f_fll_ids_increase(const uint16_t step, f_fll_ids_t *ids) {
+  f_status_t f_fll_ids_increase(const f_array_length_t step, f_fll_ids_t *ids) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!ids) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_fll_idss_decrease_by_
 
 #ifndef _di_f_fll_idss_increase_
-  f_status_t f_fll_idss_increase(const uint16_t step, f_fll_idss_t *idss) {
+  f_status_t f_fll_idss_increase(const f_array_length_t step, f_fll_idss_t *idss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!idss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/fll_id.h b/level_0/f_type_array/c/type_array/fll_id.h
index 129e8cb..14cf1bd 100644
--- a/level_0/f_type_array/c/type_array/fll_id.h
+++ b/level_0/f_type_array/c/type_array/fll_id.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_fll_ids_increase_
-  extern f_status_t f_fll_ids_increase(const uint16_t step, f_fll_ids_t *ids);
+  extern f_status_t f_fll_ids_increase(const f_array_length_t step, f_fll_ids_t *ids);
 #endif // _di_f_fll_ids_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_fll_idss_increase_
-  extern f_status_t f_fll_idss_increase(const uint16_t step, f_fll_idss_t *idss);
+  extern f_status_t f_fll_idss_increase(const f_array_length_t step, f_fll_idss_t *idss);
 #endif // _di_f_fll_idss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/int128.c b/level_0/f_type_array/c/type_array/int128.c
index 5f0b801..d2f2f26 100644
--- a/level_0/f_type_array/c/type_array/int128.c
+++ b/level_0/f_type_array/c/type_array/int128.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_int128s_decrease_by_
 
 #ifndef _di_f_int128s_increase_
-  f_status_t f_int128s_increase(const uint16_t step, f_int128s_t *int128s) {
+  f_status_t f_int128s_increase(const f_array_length_t step, f_int128s_t *int128s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int128s) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_int128ss_decrease_by_
 
 #ifndef _di_f_int128ss_increase_
-  f_status_t f_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss) {
+  f_status_t f_int128ss_increase(const f_array_length_t step, f_int128ss_t *int128ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int128ss) return F_status_set_error(F_parameter);
@@ -283,7 +283,7 @@ extern "C" {
 #endif // _di_f_uint128s_decrease_by_
 
 #ifndef _di_f_uint128s_increase_
-  f_status_t f_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s) {
+  f_status_t f_uint128s_increase(const f_array_length_t step, f_uint128s_t *uint128s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint128s) return F_status_set_error(F_parameter);
@@ -401,7 +401,7 @@ extern "C" {
 #endif // _di_f_uint128ss_decrease_by_
 
 #ifndef _di_f_uint128ss_increase_
-  f_status_t f_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss) {
+  f_status_t f_uint128ss_increase(const f_array_length_t step, f_uint128ss_t *uint128ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint128ss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/int128.h b/level_0/f_type_array/c/type_array/int128.h
index 7c1527f..843773b 100644
--- a/level_0/f_type_array/c/type_array/int128.h
+++ b/level_0/f_type_array/c/type_array/int128.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int128s_increase_
-  extern f_status_t f_int128s_increase(const uint16_t step, f_int128s_t *int128s);
+  extern f_status_t f_int128s_increase(const f_array_length_t step, f_int128s_t *int128s);
 #endif // _di_f_int128s_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int128ss_increase_
-  extern f_status_t f_int128ss_increase(const uint16_t step, f_int128ss_t *int128ss);
+  extern f_status_t f_int128ss_increase(const f_array_length_t step, f_int128ss_t *int128ss);
 #endif // _di_f_int128ss_increase_
 
 /**
@@ -455,7 +455,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint128s_increase_
-  extern f_status_t f_uint128s_increase(const uint16_t step, f_uint128s_t *uint128s);
+  extern f_status_t f_uint128s_increase(const f_array_length_t step, f_uint128s_t *uint128s);
 #endif // _di_f_uint128s_increase_
 
 /**
@@ -632,7 +632,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint128ss_increase_
-  extern f_status_t f_uint128ss_increase(const uint16_t step, f_uint128ss_t *uint128ss);
+  extern f_status_t f_uint128ss_increase(const f_array_length_t step, f_uint128ss_t *uint128ss);
 #endif // _di_f_uint128ss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/int16.c b/level_0/f_type_array/c/type_array/int16.c
index ab7d74f..d5f8857 100644
--- a/level_0/f_type_array/c/type_array/int16.c
+++ b/level_0/f_type_array/c/type_array/int16.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_int16s_decrease_by_
 
 #ifndef _di_f_int16s_increase_
-  f_status_t f_int16s_increase(const uint16_t step, f_int16s_t *int16s) {
+  f_status_t f_int16s_increase(const f_array_length_t step, f_int16s_t *int16s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int16s) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_int16ss_decrease_by_
 
 #ifndef _di_f_int16ss_increase_
-  f_status_t f_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss) {
+  f_status_t f_int16ss_increase(const f_array_length_t step, f_int16ss_t *int16ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int16ss) return F_status_set_error(F_parameter);
@@ -283,7 +283,7 @@ extern "C" {
 #endif // _di_f_uint16s_decrease_by_
 
 #ifndef _di_f_uint16s_increase_
-  f_status_t f_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s) {
+  f_status_t f_uint16s_increase(const f_array_length_t step, f_uint16s_t *uint16s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint16s) return F_status_set_error(F_parameter);
@@ -401,7 +401,7 @@ extern "C" {
 #endif // _di_f_uint16ss_decrease_by_
 
 #ifndef _di_f_uint16ss_increase_
-  f_status_t f_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss) {
+  f_status_t f_uint16ss_increase(const f_array_length_t step, f_uint16ss_t *uint16ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint16ss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/int16.h b/level_0/f_type_array/c/type_array/int16.h
index 01ecf8b..dfb00af 100644
--- a/level_0/f_type_array/c/type_array/int16.h
+++ b/level_0/f_type_array/c/type_array/int16.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int16s_increase_
-  extern f_status_t f_int16s_increase(const uint16_t step, f_int16s_t *int16s);
+  extern f_status_t f_int16s_increase(const f_array_length_t step, f_int16s_t *int16s);
 #endif // _di_f_int16s_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int16ss_increase_
-  extern f_status_t f_int16ss_increase(const uint16_t step, f_int16ss_t *int16ss);
+  extern f_status_t f_int16ss_increase(const f_array_length_t step, f_int16ss_t *int16ss);
 #endif // _di_f_int16ss_increase_
 
 /**
@@ -455,7 +455,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint16s_increase_
-  extern f_status_t f_uint16s_increase(const uint16_t step, f_uint16s_t *uint16s);
+  extern f_status_t f_uint16s_increase(const f_array_length_t step, f_uint16s_t *uint16s);
 #endif // _di_f_uint16s_increase_
 
 /**
@@ -632,7 +632,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint16ss_increase_
-  extern f_status_t f_uint16ss_increase(const uint16_t step, f_uint16ss_t *uint16ss);
+  extern f_status_t f_uint16ss_increase(const f_array_length_t step, f_uint16ss_t *uint16ss);
 #endif // _di_f_uint16ss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/int32.c b/level_0/f_type_array/c/type_array/int32.c
index 1cc48dd..e1a98d6 100644
--- a/level_0/f_type_array/c/type_array/int32.c
+++ b/level_0/f_type_array/c/type_array/int32.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_int32s_decrease_by_
 
 #ifndef _di_f_int32s_increase_
-  f_status_t f_int32s_increase(const uint16_t step, f_int32s_t *int32s) {
+  f_status_t f_int32s_increase(const f_array_length_t step, f_int32s_t *int32s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int32s) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_int32ss_decrease_by_
 
 #ifndef _di_f_int32ss_increase_
-  f_status_t f_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss) {
+  f_status_t f_int32ss_increase(const f_array_length_t step, f_int32ss_t *int32ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int32ss) return F_status_set_error(F_parameter);
@@ -283,7 +283,7 @@ extern "C" {
 #endif // _di_f_uint32s_decrease_by_
 
 #ifndef _di_f_uint32s_increase_
-  f_status_t f_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s) {
+  f_status_t f_uint32s_increase(const f_array_length_t step, f_uint32s_t *uint32s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint32s) return F_status_set_error(F_parameter);
@@ -401,7 +401,7 @@ extern "C" {
 #endif // _di_f_uint32ss_decrease_by_
 
 #ifndef _di_f_uint32ss_increase_
-  f_status_t f_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss) {
+  f_status_t f_uint32ss_increase(const f_array_length_t step, f_uint32ss_t *uint32ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint32ss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/int32.h b/level_0/f_type_array/c/type_array/int32.h
index 5e1fe91..ea6aa1d 100644
--- a/level_0/f_type_array/c/type_array/int32.h
+++ b/level_0/f_type_array/c/type_array/int32.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int32s_increase_
-  extern f_status_t f_int32s_increase(const uint16_t step, f_int32s_t *int32s);
+  extern f_status_t f_int32s_increase(const f_array_length_t step, f_int32s_t *int32s);
 #endif // _di_f_int32s_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int32ss_increase_
-  extern f_status_t f_int32ss_increase(const uint16_t step, f_int32ss_t *int32ss);
+  extern f_status_t f_int32ss_increase(const f_array_length_t step, f_int32ss_t *int32ss);
 #endif // _di_f_int32ss_increase_
 
 /**
@@ -455,7 +455,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint32s_increase_
-  extern f_status_t f_uint32s_increase(const uint16_t step, f_uint32s_t *uint32s);
+  extern f_status_t f_uint32s_increase(const f_array_length_t step, f_uint32s_t *uint32s);
 #endif // _di_f_uint32s_increase_
 
 /**
@@ -632,7 +632,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint32ss_increase_
-  extern f_status_t f_uint32ss_increase(const uint16_t step, f_uint32ss_t *uint32ss);
+  extern f_status_t f_uint32ss_increase(const f_array_length_t step, f_uint32ss_t *uint32ss);
 #endif // _di_f_uint32ss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/int64.c b/level_0/f_type_array/c/type_array/int64.c
index a5bab9d..3568eb6 100644
--- a/level_0/f_type_array/c/type_array/int64.c
+++ b/level_0/f_type_array/c/type_array/int64.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_int64s_decrease_by_
 
 #ifndef _di_f_int64s_increase_
-  f_status_t f_int64s_increase(const uint16_t step, f_int64s_t *int64s) {
+  f_status_t f_int64s_increase(const f_array_length_t step, f_int64s_t *int64s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int64s) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_int64ss_decrease_by_
 
 #ifndef _di_f_int64ss_increase_
-  f_status_t f_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss) {
+  f_status_t f_int64ss_increase(const f_array_length_t step, f_int64ss_t *int64ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int64ss) return F_status_set_error(F_parameter);
@@ -283,7 +283,7 @@ extern "C" {
 #endif // _di_f_uint64s_decrease_by_
 
 #ifndef _di_f_uint64s_increase_
-  f_status_t f_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s) {
+  f_status_t f_uint64s_increase(const f_array_length_t step, f_uint64s_t *uint64s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint64s) return F_status_set_error(F_parameter);
@@ -401,7 +401,7 @@ extern "C" {
 #endif // _di_f_uint64ss_decrease_by_
 
 #ifndef _di_f_uint64ss_increase_
-  f_status_t f_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss) {
+  f_status_t f_uint64ss_increase(const f_array_length_t step, f_uint64ss_t *uint64ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint64ss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/int64.h b/level_0/f_type_array/c/type_array/int64.h
index 0290d5b..5bcacc3 100644
--- a/level_0/f_type_array/c/type_array/int64.h
+++ b/level_0/f_type_array/c/type_array/int64.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int64s_increase_
-  extern f_status_t f_int64s_increase(const uint16_t step, f_int64s_t *int64s);
+  extern f_status_t f_int64s_increase(const f_array_length_t step, f_int64s_t *int64s);
 #endif // _di_f_int64s_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int64ss_increase_
-  extern f_status_t f_int64ss_increase(const uint16_t step, f_int64ss_t *int64ss);
+  extern f_status_t f_int64ss_increase(const f_array_length_t step, f_int64ss_t *int64ss);
 #endif // _di_f_int64ss_increase_
 
 /**
@@ -455,7 +455,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint64s_increase_
-  extern f_status_t f_uint64s_increase(const uint16_t step, f_uint64s_t *uint64s);
+  extern f_status_t f_uint64s_increase(const f_array_length_t step, f_uint64s_t *uint64s);
 #endif // _di_f_uint64s_increase_
 
 /**
@@ -632,7 +632,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint64ss_increase_
-  extern f_status_t f_uint64ss_increase(const uint16_t step, f_uint64ss_t *uint64ss);
+  extern f_status_t f_uint64ss_increase(const f_array_length_t step, f_uint64ss_t *uint64ss);
 #endif // _di_f_uint64ss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/int8.c b/level_0/f_type_array/c/type_array/int8.c
index 109f9a8..735d319 100644
--- a/level_0/f_type_array/c/type_array/int8.c
+++ b/level_0/f_type_array/c/type_array/int8.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_int8s_decrease_by_
 
 #ifndef _di_f_int8s_increase_
-  f_status_t f_int8s_increase(const uint16_t step, f_int8s_t *int8s) {
+  f_status_t f_int8s_increase(const f_array_length_t step, f_int8s_t *int8s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int8s) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_int8ss_decrease_by_
 
 #ifndef _di_f_int8ss_increase_
-  f_status_t f_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss) {
+  f_status_t f_int8ss_increase(const f_array_length_t step, f_int8ss_t *int8ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!int8ss) return F_status_set_error(F_parameter);
@@ -283,7 +283,7 @@ extern "C" {
 #endif // _di_f_uint8s_decrease_by_
 
 #ifndef _di_f_uint8s_increase_
-  f_status_t f_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s) {
+  f_status_t f_uint8s_increase(const f_array_length_t step, f_uint8s_t *uint8s) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint8s) return F_status_set_error(F_parameter);
@@ -401,7 +401,7 @@ extern "C" {
 #endif // _di_f_uint8ss_decrease_by_
 
 #ifndef _di_f_uint8ss_increase_
-  f_status_t f_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss) {
+  f_status_t f_uint8ss_increase(const f_array_length_t step, f_uint8ss_t *uint8ss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!uint8ss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/int8.h b/level_0/f_type_array/c/type_array/int8.h
index 36bdf73..6163da3 100644
--- a/level_0/f_type_array/c/type_array/int8.h
+++ b/level_0/f_type_array/c/type_array/int8.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int8s_increase_
-  extern f_status_t f_int8s_increase(const uint16_t step, f_int8s_t *int8s);
+  extern f_status_t f_int8s_increase(const f_array_length_t step, f_int8s_t *int8s);
 #endif // _di_f_int8s_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_int8ss_increase_
-  extern f_status_t f_int8ss_increase(const uint16_t step, f_int8ss_t *int8ss);
+  extern f_status_t f_int8ss_increase(const f_array_length_t step, f_int8ss_t *int8ss);
 #endif // _di_f_int8ss_increase_
 
 /**
@@ -455,7 +455,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint8s_increase_
-  extern f_status_t f_uint8s_increase(const uint16_t step, f_uint8s_t *uint8s);
+  extern f_status_t f_uint8s_increase(const f_array_length_t step, f_uint8s_t *uint8s);
 #endif // _di_f_uint8s_increase_
 
 /**
@@ -632,7 +632,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_uint8ss_increase_
-  extern f_status_t f_uint8ss_increase(const uint16_t step, f_uint8ss_t *uint8ss);
+  extern f_status_t f_uint8ss_increase(const f_array_length_t step, f_uint8ss_t *uint8ss);
 #endif // _di_f_uint8ss_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/private-fll_id.h b/level_0/f_type_array/c/type_array/private-fll_id.h
index 2e98e15..c6db12e 100644
--- a/level_0/f_type_array/c/type_array/private-fll_id.h
+++ b/level_0/f_type_array/c/type_array/private-fll_id.h
@@ -16,398 +16,14 @@ extern "C" {
 #endif
 
 /**
- * Private implementation for resizing the statuss array.
+ * Private implementation for resizing the fll_ids array.
  *
  * Intended to be shared to each of the different implementation variations.
  *
  * @param length
  *   The length to adjust to.
- * @param statuss
- *   The statuss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_statuss_adjust()
- * @see f_statuss_decimate_by()
- */
-#if !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
-  extern f_status_t private_f_statuss_adjust(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_statuss_adjust_) || !defined(_di_f_statuss_decimate_by_)
-
-/**
- * Private implementation for appending the status array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source statuss to append.
- * @param destination
- *   The destination statuss the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_statuss_append()
- * @see f_statusss_append()
- */
-#if !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
-  extern f_status_t private_f_statuss_append(const f_statuss_t source, f_statuss_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_statuss_append_) || !defined(_di_f_statusss_append_)
-
-/**
- * Private implementation for resizing the statuss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param statuss
- *   The statuss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_statuss_resize()
- * @see f_statuss_append()
- * @see f_statuss_decimate_by()
- * @see f_statusss_append()
- */
-#if !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
-  extern f_status_t private_f_statuss_resize(const f_array_length_t length, f_statuss_t *statuss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_statuss_resize_) || !defined(_di_f_statuss_append_) || !defined(_di_f_statuss_decimate_by_) || !defined(_di_f_statusss_append_)
-
-/**
- * Private implementation for resizing the statusss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param statusss
- *   The statusss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_statusss_adjust()
- * @see f_statusss_decimate_by()
- */
-#if !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
-  extern f_status_t private_f_statusss_adjust(const f_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_statusss_adjust_) || !defined(_di_f_statusss_decimate_by_)
-
-/**
- * Private implementation for resizing the statusss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param statusss
- *   The statusss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_statusss_decrease_by()
- * @see f_statusss_increase()
- * @see f_statusss_increase_by()
- * @see f_statusss_resize()
- */
-#if !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_)
-  extern f_status_t private_f_statusss_resize(const f_array_length_t length, f_statusss_t *statusss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_statusss_decrease_by_) || !defined(_di_f_statusss_increase_) || !defined(_di_f_statusss_increase_by_) || !defined(_di_f_statusss_resize_)
-
-/**
- * Private implementation for resizing the states array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param states
- *   The states array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_states_adjust()
- * @see f_states_decimate_by()
- */
-#if !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
-  extern f_status_t private_f_states_adjust(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_states_adjust_) || !defined(_di_f_states_decimate_by_)
-
-/**
- * Private implementation for appending the state array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source states to append.
- * @param destination
- *   The destination states the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_states_append()
- * @see f_statess_append()
- */
-#if !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
-  extern f_status_t private_f_states_append(const f_states_t source, f_states_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_states_append_) || !defined(_di_f_statess_append_)
-
-/**
- * Private implementation for resizing the states array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param states
- *   The states array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_states_resize()
- * @see f_states_append()
- * @see f_states_decimate_by()
- * @see f_statess_append()
- */
-#if !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
-  extern f_status_t private_f_states_resize(const f_array_length_t length, f_states_t *states) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_states_resize_) || !defined(_di_f_states_append_) || !defined(_di_f_states_decimate_by_) || !defined(_di_f_statess_append_)
-
-/**
- * Private implementation for resizing the statess array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param statess
- *   The statess array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_statess_adjust()
- * @see f_statess_decimate_by()
- */
-#if !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
-  extern f_status_t private_f_statess_adjust(const f_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_statess_adjust_) || !defined(_di_f_statess_decimate_by_)
-
-/**
- * Private implementation for resizing the statess array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param statess
- *   The statess array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_statess_decrease_by()
- * @see f_statess_increase()
- * @see f_statess_increase_by()
- * @see f_statess_resize()
- */
-#if !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_)
-  extern f_status_t private_f_statess_resize(const f_array_length_t length, f_statess_t *statess) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_statess_decrease_by_) || !defined(_di_f_statess_increase_) || !defined(_di_f_statess_increase_by_) || !defined(_di_f_statess_resize_)
-
-/**
- * Private implementation for resizing the cells array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param cells
- *   The cells array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_cells_adjust()
- * @see f_cells_decimate_by()
- */
-#if !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
-  extern f_status_t private_f_cells_adjust(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_cells_adjust_) || !defined(_di_f_cells_decimate_by_)
-
-/**
- * Private implementation for appending the cell array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source cells to append.
- * @param destination
- *   The destination cells the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_cells_append()
- * @see f_cellss_append()
- */
-#if !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
-  extern f_status_t private_f_cells_append(const f_cells_t source, f_cells_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_cells_append_) || !defined(_di_f_cellss_append_)
-
-/**
- * Private implementation for resizing the cells array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param cells
- *   The cells array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_cells_resize()
- * @see f_cells_append()
- * @see f_cells_decimate_by()
- * @see f_cellss_append()
- */
-#if !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
-  extern f_status_t private_f_cells_resize(const f_array_length_t length, f_cells_t *cells) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_cells_resize_) || !defined(_di_f_cells_append_) || !defined(_di_f_cells_decimate_by_) || !defined(_di_f_cellss_append_)
-
-/**
- * Private implementation for resizing the cellss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param cellss
- *   The cellss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_cellss_adjust()
- * @see f_cellss_decimate_by()
- */
-#if !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
-  extern f_status_t private_f_cellss_adjust(const f_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_cellss_adjust_) || !defined(_di_f_cellss_decimate_by_)
-
-/**
- * Private implementation for resizing the cellss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param cellss
- *   The cellss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_cellss_decrease_by()
- * @see f_cellss_increase()
- * @see f_cellss_increase_by()
- * @see f_cellss_resize()
- */
-#if !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_)
-  extern f_status_t private_f_cellss_resize(const f_array_length_t length, f_cellss_t *cellss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_cellss_decrease_by_) || !defined(_di_f_cellss_increase_) || !defined(_di_f_cellss_increase_by_) || !defined(_di_f_cellss_resize_)
-
-/**
- * Private implementation for resizing the ids array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param ids
- *   The ids array to adjust.
+ * @param fll_ids
+ *   The fll_ids array to adjust.
  *
  * @return
  *   F_none on success.
@@ -419,7 +35,7 @@ extern "C" {
  * @see f_fll_ids_decimate_by()
  */
 #if !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
-  extern f_status_t private_f_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_fll_ids_adjust(const f_array_length_t length, f_fll_ids_t *fll_ids) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_fll_ids_adjust_) || !defined(_di_f_fll_ids_decimate_by_)
 
 /**
@@ -428,9 +44,9 @@ extern "C" {
  * Intended to be shared to each of the different implementation variations.
  *
  * @param source
- *   The source ids to append.
+ *   The source fll_ids to append.
  * @param destination
- *   The destination ids the source is appended onto.
+ *   The destination fll_ids the source is appended onto.
  *
  * @return
  *   F_none on success.
@@ -445,14 +61,14 @@ extern "C" {
 #endif // !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_idss_append_)
 
 /**
- * Private implementation for resizing the ids array.
+ * Private implementation for resizing the fll_ids array.
  *
  * Intended to be shared to each of the different implementation variations.
  *
  * @param length
  *   The length to adjust to.
- * @param ids
- *   The ids array to adjust.
+ * @param fll_ids
+ *   The fll_ids array to adjust.
  *
  * @return
  *   F_none on success.
@@ -466,18 +82,18 @@ extern "C" {
  * @see f_fll_idss_append()
  */
 #if !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decimate_by_) || !defined(_di_f_fll_idss_append_)
-  extern f_status_t private_f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *ids) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_fll_ids_resize(const f_array_length_t length, f_fll_ids_t *fll_ids) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_fll_ids_resize_) || !defined(_di_f_fll_ids_append_) || !defined(_di_f_fll_ids_decimate_by_) || !defined(_di_f_fll_idss_append_)
 
 /**
- * Private implementation for resizing the idss array.
+ * Private implementation for resizing the fll_idss array.
  *
  * Intended to be shared to each of the different implementation variations.
  *
  * @param length
  *   The length to adjust to.
- * @param idss
- *   The idss array to adjust.
+ * @param fll_idss
+ *   The fll_idss array to adjust.
  *
  * @return
  *   F_none on success.
@@ -494,18 +110,18 @@ extern "C" {
  * @see f_fll_idss_decimate_by()
  */
 #if !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
-  extern f_status_t private_f_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *idss) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_fll_idss_adjust(const f_array_length_t length, f_fll_idss_t *fll_idss) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_fll_idss_adjust_) || !defined(_di_f_fll_idss_decimate_by_)
 
 /**
- * Private implementation for resizing the idss array.
+ * Private implementation for resizing the fll_idss array.
  *
  * Intended to be shared to each of the different implementation variations.
  *
  * @param length
  *   The length to resize to.
- * @param idss
- *   The idss array to resize.
+ * @param fll_idss
+ *   The fll_idss array to resize.
  *
  * @return
  *   F_none on success.
@@ -524,1415 +140,8 @@ extern "C" {
  * @see f_fll_idss_resize()
  */
 #if !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_)
-  extern f_status_t private_f_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *idss) F_attribute_visibility_internal_d;
+  extern f_status_t private_f_fll_idss_resize(const f_array_length_t length, f_fll_idss_t *fll_idss) F_attribute_visibility_internal_d;
 #endif // !defined(_di_f_fll_idss_decrease_by_) || !defined(_di_f_fll_idss_increase_) || !defined(_di_f_fll_idss_increase_by_) || !defined(_di_f_fll_idss_resize_)
-/**
- * Private implementation for resizing the array_lengths array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param lengths
- *   The lengths array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_array_lengths_adjust()
- * @see f_array_lengths_decimate_by()
- */
-#if !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
-  extern f_status_t private_f_array_lengths_adjust(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_array_lengths_adjust_) || !defined(_di_f_array_lengths_decimate_by_)
-
-/**
- * Private implementation for appending the array_length array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source array_lengths to append.
- * @param destination
- *   The destination lengths the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_array_lengths_append()
- * @see f_array_lengthss_append()
- */
-#if !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
-  extern f_status_t private_f_array_lengths_append(const f_array_lengths_t source, f_array_lengths_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengthss_append_)
-
-/**
- * Private implementation for resizing the array_lengths array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param lengths
- *   The lengths array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_array_lengths_resize()
- * @see f_array_lengths_append()
- * @see f_array_lengths_decimate_by()
- * @see f_array_lengthss_append()
- */
-#if !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
-  extern f_status_t private_f_array_lengths_resize(const f_array_length_t length, f_array_lengths_t *lengths) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_array_lengths_resize_) || !defined(_di_f_array_lengths_append_) || !defined(_di_f_array_lengths_decimate_by_) || !defined(_di_f_array_lengthss_append_)
-
-/**
- * Private implementation for resizing the lengthss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param lengthss
- *   The lengthss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_array_lengthss_adjust()
- * @see f_array_lengthss_decimate_by()
- */
-#if !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
-  extern f_status_t private_f_array_lengthss_adjust(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_array_lengthss_adjust_) || !defined(_di_f_array_lengthss_decimate_by_)
-
-/**
- * Private implementation for resizing the lengthss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param lengthss
- *   The lengthss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_array_lengthss_decrease_by()
- * @see f_array_lengthss_increase()
- * @see f_array_lengthss_increase_by()
- * @see f_array_lengthss_resize()
- */
-#if !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
-  extern f_status_t private_f_array_lengthss_resize(const f_array_length_t length, f_array_lengthss_t *lengthss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_array_lengthss_decrease_by_) || !defined(_di_f_array_lengthss_increase_) || !defined(_di_f_array_lengthss_increase_by_) || !defined(_di_f_array_lengthss_resize_)
-
-/**
- * Private implementation for resizing the int8s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int8s
- *   The int8s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_int8s_adjust()
- * @see f_int8s_decimate_by()
- */
-#if !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
-  extern f_status_t private_f_int8s_adjust(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int8s_adjust_) || !defined(_di_f_int8s_decimate_by_)
-
-/**
- * Private implementation for appending the int8 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source int8s to append.
- * @param destination
- *   The destination int8s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int8s_append()
- * @see f_int8ss_append()
- */
-#if !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
-  extern f_status_t private_f_int8s_append(const f_int8s_t source, f_int8s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int8s_append_) || !defined(_di_f_int8ss_append_)
-
-/**
- * Private implementation for resizing the int8s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int8s
- *   The int8s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int8s_resize()
- * @see f_int8s_append()
- * @see f_int8s_decimate_by()
- * @see f_int8ss_append()
- */
-#if !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
-  extern f_status_t private_f_int8s_resize(const f_array_length_t length, f_int8s_t *int8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int8s_resize_) || !defined(_di_f_int8s_append_) || !defined(_di_f_int8s_decimate_by_) || !defined(_di_f_int8ss_append_)
-
-/**
- * Private implementation for resizing the int8ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int8ss
- *   The int8ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_int8ss_adjust()
- * @see f_int8ss_decimate_by()
- */
-#if !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
-  extern f_status_t private_f_int8ss_adjust(const f_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int8ss_adjust_) || !defined(_di_f_int8ss_decimate_by_)
-
-/**
- * Private implementation for resizing the int8ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param int8ss
- *   The int8ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int8ss_decrease_by()
- * @see f_int8ss_increase()
- * @see f_int8ss_increase_by()
- * @see f_int8ss_resize()
- */
-#if !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_)
-  extern f_status_t private_f_int8ss_resize(const f_array_length_t length, f_int8ss_t *int8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int8ss_decrease_by_) || !defined(_di_f_int8ss_increase_) || !defined(_di_f_int8ss_increase_by_) || !defined(_di_f_int8ss_resize_)
-
-/**
- * Private implementation for resizing the uint8s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint8s
- *   The uint8s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_uint8s_adjust()
- * @see f_uint8s_decimate_by()
- */
-#if !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
-  extern f_status_t private_f_uint8s_adjust(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint8s_adjust_) || !defined(_di_f_uint8s_decimate_by_)
-
-/**
- * Private implementation for appending the uint8 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source uint8s to append.
- * @param destination
- *   The destination uint8s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint8s_append()
- * @see f_uint8ss_append()
- */
-#if !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
-  extern f_status_t private_f_uint8s_append(const f_uint8s_t source, f_uint8s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8ss_append_)
-
-/**
- * Private implementation for resizing the uint8s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint8s
- *   The uint8s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint8s_resize()
- * @see f_uint8s_append()
- * @see f_uint8s_decimate_by()
- * @see f_uint8ss_append()
- */
-#if !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
-  extern f_status_t private_f_uint8s_resize(const f_array_length_t length, f_uint8s_t *uint8s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint8s_resize_) || !defined(_di_f_uint8s_append_) || !defined(_di_f_uint8s_decimate_by_) || !defined(_di_f_uint8ss_append_)
-
-/**
- * Private implementation for resizing the uint8ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint8ss
- *   The uint8ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_uint8ss_adjust()
- * @see f_uint8ss_decimate_by()
- */
-#if !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
-  extern f_status_t private_f_uint8ss_adjust(const f_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint8ss_adjust_) || !defined(_di_f_uint8ss_decimate_by_)
-
-/**
- * Private implementation for resizing the uint8ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param uint8ss
- *   The uint8ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint8ss_decrease_by()
- * @see f_uint8ss_increase()
- * @see f_uint8ss_increase_by()
- * @see f_uint8ss_resize()
- */
-#if !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_)
-  extern f_status_t private_f_uint8ss_resize(const f_array_length_t length, f_uint8ss_t *uint8ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint8ss_decrease_by_) || !defined(_di_f_uint8ss_increase_) || !defined(_di_f_uint8ss_increase_by_) || !defined(_di_f_uint8ss_resize_)
-
-/**
- * Private implementation for resizing the int16s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int16s
- *   The int16s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_int16s_adjust()
- * @see f_int16s_decimate_by()
- */
-#if !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
-  extern f_status_t private_f_int16s_adjust(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int16s_adjust_) || !defined(_di_f_int16s_decimate_by_)
-
-/**
- * Private implementation for appending the int16 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source int16s to append.
- * @param destination
- *   The destination int16s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int16s_append()
- * @see f_int16ss_append()
- */
-#if !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
-  extern f_status_t private_f_int16s_append(const f_int16s_t source, f_int16s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int16s_append_) || !defined(_di_f_int16ss_append_)
-
-/**
- * Private implementation for resizing the int16s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int16s
- *   The int16s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int16s_resize()
- * @see f_int16s_append()
- * @see f_int16s_decimate_by()
- * @see f_int16ss_append()
- */
-#if !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
-  extern f_status_t private_f_int16s_resize(const f_array_length_t length, f_int16s_t *int16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int16s_resize_) || !defined(_di_f_int16s_append_) || !defined(_di_f_int16s_decimate_by_) || !defined(_di_f_int16ss_append_)
-
-/**
- * Private implementation for resizing the int16ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int16ss
- *   The int16ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_int16ss_adjust()
- * @see f_int16ss_decimate_by()
- */
-#if !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
-  extern f_status_t private_f_int16ss_adjust(const f_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int16ss_adjust_) || !defined(_di_f_int16ss_decimate_by_)
-
-/**
- * Private implementation for resizing the int16ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param int16ss
- *   The int16ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int16ss_decrease_by()
- * @see f_int16ss_increase()
- * @see f_int16ss_increase_by()
- * @see f_int16ss_resize()
- */
-#if !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_)
-  extern f_status_t private_f_int16ss_resize(const f_array_length_t length, f_int16ss_t *int16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int16ss_decrease_by_) || !defined(_di_f_int16ss_increase_) || !defined(_di_f_int16ss_increase_by_) || !defined(_di_f_int16ss_resize_)
-
-/**
- * Private implementation for resizing the uint16s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint16s
- *   The uint16s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_uint16s_adjust()
- * @see f_uint16s_decimate_by()
- */
-#if !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
-  extern f_status_t private_f_uint16s_adjust(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint16s_adjust_) || !defined(_di_f_uint16s_decimate_by_)
-
-/**
- * Private implementation for appending the uint16 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source uint16s to append.
- * @param destination
- *   The destination uint16s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint16s_append()
- * @see f_uint16ss_append()
- */
-#if !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
-  extern f_status_t private_f_uint16s_append(const f_uint16s_t source, f_uint16s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16ss_append_)
-
-/**
- * Private implementation for resizing the uint16s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint16s
- *   The uint16s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint16s_resize()
- * @see f_uint16s_append()
- * @see f_uint16s_decimate_by()
- * @see f_uint16ss_append()
- */
-#if !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
-  extern f_status_t private_f_uint16s_resize(const f_array_length_t length, f_uint16s_t *uint16s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint16s_resize_) || !defined(_di_f_uint16s_append_) || !defined(_di_f_uint16s_decimate_by_) || !defined(_di_f_uint16ss_append_)
-
-/**
- * Private implementation for resizing the uint16ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint16ss
- *   The uint16ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_uint16ss_adjust()
- * @see f_uint16ss_decimate_by()
- */
-#if !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
-  extern f_status_t private_f_uint16ss_adjust(const f_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint16ss_adjust_) || !defined(_di_f_uint16ss_decimate_by_)
-
-/**
- * Private implementation for resizing the uint16ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param uint16ss
- *   The uint16ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint16ss_decrease_by()
- * @see f_uint16ss_increase()
- * @see f_uint16ss_increase_by()
- * @see f_uint16ss_resize()
- */
-#if !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_)
-  extern f_status_t private_f_uint16ss_resize(const f_array_length_t length, f_uint16ss_t *uint16ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint16ss_decrease_by_) || !defined(_di_f_uint16ss_increase_) || !defined(_di_f_uint16ss_increase_by_) || !defined(_di_f_uint16ss_resize_)
-
-/**
- * Private implementation for resizing the int32s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int32s
- *   The int32s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_int32s_adjust()
- * @see f_int32s_decimate_by()
- */
-#if !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
-  extern f_status_t private_f_int32s_adjust(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int32s_adjust_) || !defined(_di_f_int32s_decimate_by_)
-
-/**
- * Private implementation for appending the int32 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source int32s to append.
- * @param destination
- *   The destination int32s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int32s_append()
- * @see f_int32ss_append()
- */
-#if !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
-  extern f_status_t private_f_int32s_append(const f_int32s_t source, f_int32s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int32s_append_) || !defined(_di_f_int32ss_append_)
-
-/**
- * Private implementation for resizing the int32s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int32s
- *   The int32s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int32s_resize()
- * @see f_int32s_append()
- * @see f_int32s_decimate_by()
- * @see f_int32ss_append()
- */
-#if !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
-  extern f_status_t private_f_int32s_resize(const f_array_length_t length, f_int32s_t *int32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int32s_resize_) || !defined(_di_f_int32s_append_) || !defined(_di_f_int32s_decimate_by_) || !defined(_di_f_int32ss_append_)
-
-/**
- * Private implementation for resizing the int32ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int32ss
- *   The int32ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_int32ss_adjust()
- * @see f_int32ss_decimate_by()
- */
-#if !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
-  extern f_status_t private_f_int32ss_adjust(const f_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int32ss_adjust_) || !defined(_di_f_int32ss_decimate_by_)
-
-/**
- * Private implementation for resizing the int32ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param int32ss
- *   The int32ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int32ss_decrease_by()
- * @see f_int32ss_increase()
- * @see f_int32ss_increase_by()
- * @see f_int32ss_resize()
- */
-#if !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_)
-  extern f_status_t private_f_int32ss_resize(const f_array_length_t length, f_int32ss_t *int32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int32ss_decrease_by_) || !defined(_di_f_int32ss_increase_) || !defined(_di_f_int32ss_increase_by_) || !defined(_di_f_int32ss_resize_)
-
-/**
- * Private implementation for resizing the uint32s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint32s
- *   The uint32s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_uint32s_adjust()
- * @see f_uint32s_decimate_by()
- */
-#if !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
-  extern f_status_t private_f_uint32s_adjust(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint32s_adjust_) || !defined(_di_f_uint32s_decimate_by_)
-
-/**
- * Private implementation for appending the uint32 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source uint32s to append.
- * @param destination
- *   The destination uint32s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint32s_append()
- * @see f_uint32ss_append()
- */
-#if !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
-  extern f_status_t private_f_uint32s_append(const f_uint32s_t source, f_uint32s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32ss_append_)
-
-/**
- * Private implementation for resizing the uint32s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint32s
- *   The uint32s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint32s_resize()
- * @see f_uint32s_append()
- * @see f_uint32s_decimate_by()
- * @see f_uint32ss_append()
- */
-#if !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
-  extern f_status_t private_f_uint32s_resize(const f_array_length_t length, f_uint32s_t *uint32s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint32s_resize_) || !defined(_di_f_uint32s_append_) || !defined(_di_f_uint32s_decimate_by_) || !defined(_di_f_uint32ss_append_)
-
-/**
- * Private implementation for resizing the uint32ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint32ss
- *   The uint32ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_uint32ss_adjust()
- * @see f_uint32ss_decimate_by()
- */
-#if !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
-  extern f_status_t private_f_uint32ss_adjust(const f_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint32ss_adjust_) || !defined(_di_f_uint32ss_decimate_by_)
-
-/**
- * Private implementation for resizing the uint32ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param uint32ss
- *   The uint32ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint32ss_decrease_by()
- * @see f_uint32ss_increase()
- * @see f_uint32ss_increase_by()
- * @see f_uint32ss_resize()
- */
-#if !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_)
-  extern f_status_t private_f_uint32ss_resize(const f_array_length_t length, f_uint32ss_t *uint32ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint32ss_decrease_by_) || !defined(_di_f_uint32ss_increase_) || !defined(_di_f_uint32ss_increase_by_) || !defined(_di_f_uint32ss_resize_)
-
-/**
- * Private implementation for resizing the int64s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int64s
- *   The int64s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_int64s_adjust()
- * @see f_int64s_decimate_by()
- */
-#if !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
-  extern f_status_t private_f_int64s_adjust(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int64s_adjust_) || !defined(_di_f_int64s_decimate_by_)
-
-/**
- * Private implementation for appending the int64 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source int64s to append.
- * @param destination
- *   The destination int64s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int64s_append()
- * @see f_int64ss_append()
- */
-#if !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
-  extern f_status_t private_f_int64s_append(const f_int64s_t source, f_int64s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int64s_append_) || !defined(_di_f_int64ss_append_)
-
-/**
- * Private implementation for resizing the int64s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int64s
- *   The int64s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int64s_resize()
- * @see f_int64s_append()
- * @see f_int64s_decimate_by()
- * @see f_int64ss_append()
- */
-#if !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
-  extern f_status_t private_f_int64s_resize(const f_array_length_t length, f_int64s_t *int64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int64s_resize_) || !defined(_di_f_int64s_append_) || !defined(_di_f_int64s_decimate_by_) || !defined(_di_f_int64ss_append_)
-
-/**
- * Private implementation for resizing the int64ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int64ss
- *   The int64ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_int64ss_adjust()
- * @see f_int64ss_decimate_by()
- */
-#if !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
-  extern f_status_t private_f_int64ss_adjust(const f_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int64ss_adjust_) || !defined(_di_f_int64ss_decimate_by_)
-
-/**
- * Private implementation for resizing the int64ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param int64ss
- *   The int64ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int64ss_decrease_by()
- * @see f_int64ss_increase()
- * @see f_int64ss_increase_by()
- * @see f_int64ss_resize()
- */
-#if !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_)
-  extern f_status_t private_f_int64ss_resize(const f_array_length_t length, f_int64ss_t *int64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int64ss_decrease_by_) || !defined(_di_f_int64ss_increase_) || !defined(_di_f_int64ss_increase_by_) || !defined(_di_f_int64ss_resize_)
-
-/**
- * Private implementation for resizing the uint64s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint64s
- *   The uint64s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_uint64s_adjust()
- * @see f_uint64s_decimate_by()
- */
-#if !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
-  extern f_status_t private_f_uint64s_adjust(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint64s_adjust_) || !defined(_di_f_uint64s_decimate_by_)
-
-/**
- * Private implementation for appending the uint64 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source uint64s to append.
- * @param destination
- *   The destination uint64s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint64s_append()
- * @see f_uint64ss_append()
- */
-#if !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
-  extern f_status_t private_f_uint64s_append(const f_uint64s_t source, f_uint64s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64ss_append_)
-
-/**
- * Private implementation for resizing the uint64s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint64s
- *   The uint64s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint64s_resize()
- * @see f_uint64s_append()
- * @see f_uint64s_decimate_by()
- * @see f_uint64ss_append()
- */
-#if !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
-  extern f_status_t private_f_uint64s_resize(const f_array_length_t length, f_uint64s_t *uint64s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint64s_resize_) || !defined(_di_f_uint64s_append_) || !defined(_di_f_uint64s_decimate_by_) || !defined(_di_f_uint64ss_append_)
-
-/**
- * Private implementation for resizing the uint64ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint64ss
- *   The uint64ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_uint64ss_adjust()
- * @see f_uint64ss_decimate_by()
- */
-#if !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
-  extern f_status_t private_f_uint64ss_adjust(const f_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint64ss_adjust_) || !defined(_di_f_uint64ss_decimate_by_)
-
-/**
- * Private implementation for resizing the uint64ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param uint64ss
- *   The uint64ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint64ss_decrease_by()
- * @see f_uint64ss_increase()
- * @see f_uint64ss_increase_by()
- * @see f_uint64ss_resize()
- */
-#if !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_)
-  extern f_status_t private_f_uint64ss_resize(const f_array_length_t length, f_uint64ss_t *uint64ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint64ss_decrease_by_) || !defined(_di_f_uint64ss_increase_) || !defined(_di_f_uint64ss_increase_by_) || !defined(_di_f_uint64ss_resize_)
-
-/**
- * Private implementation for resizing the int128s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int128s
- *   The int128s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_int128s_adjust()
- * @see f_int128s_decimate_by()
- */
-#if !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
-  extern f_status_t private_f_int128s_adjust(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int128s_adjust_) || !defined(_di_f_int128s_decimate_by_)
-
-/**
- * Private implementation for appending the int128 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source int128s to append.
- * @param destination
- *   The destination int128s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int128s_append()
- * @see f_int128ss_append()
- */
-#if !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
-  extern f_status_t private_f_int128s_append(const f_int128s_t source, f_int128s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int128s_append_) || !defined(_di_f_int128ss_append_)
-
-/**
- * Private implementation for resizing the int128s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int128s
- *   The int128s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int128s_resize()
- * @see f_int128s_append()
- * @see f_int128s_decimate_by()
- * @see f_int128ss_append()
- */
-#if !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
-  extern f_status_t private_f_int128s_resize(const f_array_length_t length, f_int128s_t *int128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int128s_resize_) || !defined(_di_f_int128s_append_) || !defined(_di_f_int128s_decimate_by_) || !defined(_di_f_int128ss_append_)
-
-/**
- * Private implementation for resizing the int128ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param int128ss
- *   The int128ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_int128ss_adjust()
- * @see f_int128ss_decimate_by()
- */
-#if !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
-  extern f_status_t private_f_int128ss_adjust(const f_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int128ss_adjust_) || !defined(_di_f_int128ss_decimate_by_)
-
-/**
- * Private implementation for resizing the int128ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param int128ss
- *   The int128ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_int128ss_decrease_by()
- * @see f_int128ss_increase()
- * @see f_int128ss_increase_by()
- * @see f_int128ss_resize()
- */
-#if !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_)
-  extern f_status_t private_f_int128ss_resize(const f_array_length_t length, f_int128ss_t *int128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_int128ss_decrease_by_) || !defined(_di_f_int128ss_increase_) || !defined(_di_f_int128ss_increase_by_) || !defined(_di_f_int128ss_resize_)
-
-/**
- * Private implementation for resizing the uint128s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint128s
- *   The uint128s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *
- * @see f_uint128s_adjust()
- * @see f_uint128s_decimate_by()
- */
-#if !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
-  extern f_status_t private_f_uint128s_adjust(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint128s_adjust_) || !defined(_di_f_uint128s_decimate_by_)
-
-/**
- * Private implementation for appending the uint128 array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param source
- *   The source uint128s to append.
- * @param destination
- *   The destination uint128s the source is appended onto.
- *
- * @return
- *   F_none on success.
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint128s_append()
- * @see f_uint128ss_append()
- */
-#if !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
-  extern f_status_t private_f_uint128s_append(const f_uint128s_t source, f_uint128s_t *destination) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128ss_append_)
-
-/**
- * Private implementation for resizing the uint128s array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint128s
- *   The uint128s array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint128s_resize()
- * @see f_uint128s_append()
- * @see f_uint128s_decimate_by()
- * @see f_uint128ss_append()
- */
-#if !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
-  extern f_status_t private_f_uint128s_resize(const f_array_length_t length, f_uint128s_t *uint128s) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint128s_resize_) || !defined(_di_f_uint128s_append_) || !defined(_di_f_uint128s_decimate_by_) || !defined(_di_f_uint128ss_append_)
-
-/**
- * Private implementation for resizing the uint128ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to adjust to.
- * @param uint128ss
- *   The uint128ss array to adjust.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_adjust().
- *   Errors (with error bit) from: f_memory_destroy().
- *
- * @see f_uint128ss_adjust()
- * @see f_uint128ss_decimate_by()
- */
-#if !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
-  extern f_status_t private_f_uint128ss_adjust(const f_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint128ss_adjust_) || !defined(_di_f_uint128ss_decimate_by_)
-
-/**
- * Private implementation for resizing the uint128ss array.
- *
- * Intended to be shared to each of the different implementation variations.
- *
- * @param length
- *   The length to resize to.
- * @param uint128ss
- *   The uint128ss array to resize.
- *
- * @return
- *   F_none on success.
- *   F_data_not on success, but there is no reason to increase size (used + 1 <= size).
- *
- *   F_array_too_large (with error bit) if new length is larger than max array length.
- *   F_memory_not (with error bit) on out of memory.
- *   F_parameter (with error bit) if a parameter is invalid.
- *
- *   Errors (with error bit) from: f_memory_delete().
- *   Errors (with error bit) from: f_memory_resize().
- *
- * @see f_uint128ss_decrease_by()
- * @see f_uint128ss_increase()
- * @see f_uint128ss_increase_by()
- * @see f_uint128ss_resize()
- */
-#if !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_)
-  extern f_status_t private_f_uint128ss_resize(const f_array_length_t length, f_uint128ss_t *uint128ss) F_attribute_visibility_internal_d;
-#endif // !defined(_di_f_uint128ss_decrease_by_) || !defined(_di_f_uint128ss_increase_) || !defined(_di_f_uint128ss_increase_by_) || !defined(_di_f_uint128ss_resize_)
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/level_0/f_type_array/c/type_array/state.c b/level_0/f_type_array/c/type_array/state.c
index 2273223..9aa700e 100644
--- a/level_0/f_type_array/c/type_array/state.c
+++ b/level_0/f_type_array/c/type_array/state.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_states_decrease_by_
 
 #ifndef _di_f_states_increase_
-  f_status_t f_states_increase(const uint16_t step, f_states_t *states) {
+  f_status_t f_states_increase(const f_array_length_t step, f_states_t *states) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!states) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_statess_decrease_by_
 
 #ifndef _di_f_statess_increase_
-  f_status_t f_statess_increase(const uint16_t step, f_statess_t *statess) {
+  f_status_t f_statess_increase(const f_array_length_t step, f_statess_t *statess) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!statess) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/state.h b/level_0/f_type_array/c/type_array/state.h
index 223fd80..ddd1cb1 100644
--- a/level_0/f_type_array/c/type_array/state.h
+++ b/level_0/f_type_array/c/type_array/state.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_states_increase_
-  extern f_status_t f_states_increase(const uint16_t step, f_states_t *states);
+  extern f_status_t f_states_increase(const f_array_length_t step, f_states_t *states);
 #endif // _di_f_states_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_statess_increase_
-  extern f_status_t f_statess_increase(const uint16_t step, f_statess_t *statess);
+  extern f_status_t f_statess_increase(const f_array_length_t step, f_statess_t *statess);
 #endif // _di_f_statess_increase_
 
 /**
diff --git a/level_0/f_type_array/c/type_array/status.c b/level_0/f_type_array/c/type_array/status.c
index 4c911d1..d5ed45b 100644
--- a/level_0/f_type_array/c/type_array/status.c
+++ b/level_0/f_type_array/c/type_array/status.c
@@ -59,7 +59,7 @@ extern "C" {
 #endif // _di_f_statuss_decrease_by_
 
 #ifndef _di_f_statuss_increase_
-  f_status_t f_statuss_increase(const uint16_t step, f_statuss_t *statuss) {
+  f_status_t f_statuss_increase(const f_array_length_t step, f_statuss_t *statuss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!statuss) return F_status_set_error(F_parameter);
@@ -177,7 +177,7 @@ extern "C" {
 #endif // _di_f_statusss_decrease_by_
 
 #ifndef _di_f_statusss_increase_
-  f_status_t f_statusss_increase(const uint16_t step, f_statusss_t *statusss) {
+  f_status_t f_statusss_increase(const f_array_length_t step, f_statusss_t *statusss) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!statusss) return F_status_set_error(F_parameter);
diff --git a/level_0/f_type_array/c/type_array/status.h b/level_0/f_type_array/c/type_array/status.h
index 7f743e3..ff25306 100644
--- a/level_0/f_type_array/c/type_array/status.h
+++ b/level_0/f_type_array/c/type_array/status.h
@@ -123,7 +123,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_statuss_increase_
-  extern f_status_t f_statuss_increase(const uint16_t step, f_statuss_t *statuss);
+  extern f_status_t f_statuss_increase(const f_array_length_t step, f_statuss_t *statuss);
 #endif // _di_f_statuss_increase_
 
 /**
@@ -300,7 +300,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_statusss_increase_
-  extern f_status_t f_statusss_increase(const uint16_t step, f_statusss_t *statusss);
+  extern f_status_t f_statusss_increase(const f_array_length_t step, f_statusss_t *statusss);
 #endif // _di_f_statusss_increase_
 
 /**
diff --git a/level_0/f_utf/c/utf/dynamic.c b/level_0/f_utf/c/utf/dynamic.c
index 672fe3f..c856ccb 100644
--- a/level_0/f_utf/c/utf/dynamic.c
+++ b/level_0/f_utf/c/utf/dynamic.c
@@ -158,7 +158,7 @@ extern "C" {
 #endif // _di_f_utf_string_dynamic_decrease_by_
 
 #ifndef _di_f_utf_string_dynamic_increase_
-  f_status_t f_utf_string_dynamic_increase(const uint16_t step, f_utf_string_dynamic_t *dynamic) {
+  f_status_t f_utf_string_dynamic_increase(const f_array_length_t step, f_utf_string_dynamic_t *dynamic) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!dynamic) return F_status_set_error(F_parameter);
@@ -938,7 +938,7 @@ extern "C" {
 #endif // _di_f_utf_string_dynamics_decrease_by_
 
 #ifndef _di_f_utf_string_dynamics_increase_
-  f_status_t f_utf_string_dynamics_increase(const uint16_t step, f_utf_string_dynamics_t *dynamics) {
+  f_status_t f_utf_string_dynamics_increase(const f_array_length_t step, f_utf_string_dynamics_t *dynamics) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!dynamics) return F_status_set_error(F_parameter);
diff --git a/level_0/f_utf/c/utf/dynamic.h b/level_0/f_utf/c/utf/dynamic.h
index eb44ac2b6..d29e4d7 100644
--- a/level_0/f_utf/c/utf/dynamic.h
+++ b/level_0/f_utf/c/utf/dynamic.h
@@ -303,7 +303,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_utf_string_dynamic_increase_
-  extern f_status_t f_utf_string_dynamic_increase(const uint16_t step, f_utf_string_dynamic_t *dynamic);
+  extern f_status_t f_utf_string_dynamic_increase(const f_array_length_t step, f_utf_string_dynamic_t *dynamic);
 #endif // _di_f_utf_string_dynamic_increase_
 
 /**
@@ -1135,7 +1135,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_utf_string_dynamics_increase_
-  extern f_status_t f_utf_string_dynamics_increase(const uint16_t step, f_utf_string_dynamics_t *dynamics);
+  extern f_status_t f_utf_string_dynamics_increase(const f_array_length_t step, f_utf_string_dynamics_t *dynamics);
 #endif // _di_f_utf_string_dynamics_increase_
 
 /**
diff --git a/level_0/f_utf/c/utf/map.c b/level_0/f_utf/c/utf/map.c
index 16bc6d8..9f71496 100644
--- a/level_0/f_utf/c/utf/map.c
+++ b/level_0/f_utf/c/utf/map.c
@@ -80,7 +80,7 @@ extern "C" {
 #endif // _di_f_utf_string_map_multis_decrease_by_
 
 #ifndef _di_f_utf_string_map_multis_increase_
-  f_status_t f_utf_string_map_multis_increase(const uint16_t step, f_utf_string_map_multis_t *map_multis) {
+  f_status_t f_utf_string_map_multis_increase(const f_array_length_t step, f_utf_string_map_multis_t *map_multis) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!map_multis) return F_status_set_error(F_parameter);
@@ -209,7 +209,7 @@ extern "C" {
 #endif // _di_f_utf_string_maps_decrease_by_
 
 #ifndef _di_f_utf_string_maps_increase_
-  f_status_t f_utf_string_maps_increase(const uint16_t step, f_utf_string_maps_t *maps) {
+  f_status_t f_utf_string_maps_increase(const f_array_length_t step, f_utf_string_maps_t *maps) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!maps) return F_status_set_error(F_parameter);
diff --git a/level_0/f_utf/c/utf/map.h b/level_0/f_utf/c/utf/map.h
index 0961346..6456177 100644
--- a/level_0/f_utf/c/utf/map.h
+++ b/level_0/f_utf/c/utf/map.h
@@ -240,7 +240,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_utf_string_map_multis_increase_
-  extern f_status_t f_utf_string_map_multis_increase(const uint16_t step, f_utf_string_map_multis_t *map_multis);
+  extern f_status_t f_utf_string_map_multis_increase(const f_array_length_t step, f_utf_string_map_multis_t *map_multis);
 #endif // _di_f_utf_string_map_multis_increase_
 
 /**
@@ -395,7 +395,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_utf_string_maps_increase_
-  extern f_status_t f_utf_string_maps_increase(const uint16_t step, f_utf_string_maps_t *maps);
+  extern f_status_t f_utf_string_maps_increase(const f_array_length_t step, f_utf_string_maps_t *maps);
 #endif // _di_f_utf_string_maps_increase_
 
 /**
diff --git a/level_0/f_utf/c/utf/triple.c b/level_0/f_utf/c/utf/triple.c
index 0be2923..ddcd5b7 100644
--- a/level_0/f_utf/c/utf/triple.c
+++ b/level_0/f_utf/c/utf/triple.c
@@ -90,7 +90,7 @@ extern "C" {
 #endif // _di_f_utf_string_triples_decrease_by_
 
 #ifndef _di_f_utf_string_triples_increase_
-  f_status_t f_utf_string_triples_increase(const uint16_t step, f_utf_string_triples_t *triples) {
+  f_status_t f_utf_string_triples_increase(const f_array_length_t step, f_utf_string_triples_t *triples) {
     #ifndef _di_level_0_parameter_checking_
       if (!step) return F_status_set_error(F_parameter);
       if (!triples) return F_status_set_error(F_parameter);
diff --git a/level_0/f_utf/c/utf/triple.h b/level_0/f_utf/c/utf/triple.h
index 77e1355..5871a57 100644
--- a/level_0/f_utf/c/utf/triple.h
+++ b/level_0/f_utf/c/utf/triple.h
@@ -192,7 +192,7 @@ extern "C" {
  *   Errors (with error bit) from: f_memory_resize().
  */
 #ifndef _di_f_utf_string_triples_increase_
-  extern f_status_t f_utf_string_triples_increase(const uint16_t step, f_utf_string_triples_t *triples);
+  extern f_status_t f_utf_string_triples_increase(const f_array_length_t step, f_utf_string_triples_t *triples);
 #endif // _di_f_utf_string_triples_increase_
 
 /**
diff --git a/level_1/fl_iki/c/iki.c b/level_1/fl_iki/c/iki.c
index 676d7b8..08ffd6f 100644
--- a/level_1/fl_iki/c/iki.c
+++ b/level_1/fl_iki/c/iki.c
@@ -5,7 +5,7 @@ extern "C" {
 #endif
 
 #ifndef _di_fl_iki_read_
-  f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits) {
+  f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data) {
     #ifndef _di_level_1_parameter_checking_
       if (!buffer) return F_status_set_error(F_parameter);
       if (!range) return F_status_set_error(F_parameter);
@@ -14,7 +14,7 @@ extern "C" {
     f_status_t status = F_none;
 
     do {
-      status = f_iki_read(state, buffer, range, variable, vocabulary, content, delimits);
+      status = f_iki_read(state, buffer, range, data);
       if (F_status_is_error(status)) return status;
 
       if (status == F_data_not_eos || status == F_data_not_stop) {
diff --git a/level_1/fl_iki/c/iki.h b/level_1/fl_iki/c/iki.h
index 09c8aae..385f2f2 100644
--- a/level_1/fl_iki/c/iki.h
+++ b/level_1/fl_iki/c/iki.h
@@ -51,14 +51,8 @@ extern "C" {
  *   The start location will be updated as the buffer is being processed.
  *   The start location will represent where the read stopped on return.
  *   A start location past the stop location or buffer used means that the entire range was processed.
- * @param variable
- *   The entire vocabulary name, content, and syntax.
- * @param vocabulary
- *   The vocabulary name list to store the found vocabulary names.
- * @param content
- *   The content list to store the content associated with the found vocabulary names.
- * @param delimits
- *   A delimits array representing where delimits exist within the buffer.
+ * @param data
+ *   The IKI data.
  *
  * @return
  *   F_none on success and an IKI vocabulary name was found.
@@ -75,7 +69,7 @@ extern "C" {
  * @see f_iki_read()
  */
 #ifndef _di_fl_iki_read_
-  extern f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_variable_t * const variable, f_iki_vocabulary_t * const vocabulary, f_iki_content_t * const content, f_iki_delimits_t * const delimits);
+  extern f_status_t fl_iki_read(const f_state_t state, f_string_static_t * const buffer, f_string_range_t * const range, f_iki_data_t * const data);
 #endif // _di_fl_iki_read_
 
 #ifdef __cplusplus
diff --git a/level_3/fake/c/private-make-operate.c b/level_3/fake/c/private-make-operate.c
index 95d76e0..2abbe5a 100644
--- a/level_3/fake/c/private-make-operate.c
+++ b/level_3/fake/c/private-make-operate.c
@@ -160,10 +160,7 @@ extern "C" {
     const f_string_range_t range_define = macro_f_string_range_t_initialize(F_iki_vocabulary_0002_define_s_length);
     const f_string_range_t range_parameter = macro_f_string_range_t_initialize(F_iki_vocabulary_0002_parameter_s_length);
 
-    f_iki_variable_t iki_variable = f_iki_variable_t_initialize;
-    f_iki_vocabulary_t iki_vocabulary = f_iki_vocabulary_t_initialize;
-    f_iki_content_t iki_content = f_iki_content_t_initialize;
-    f_iki_delimits_t iki_delimits = f_iki_delimits_t_initialize;
+    f_iki_data_t iki_data = f_iki_data_t_initialize;
 
     f_state_t state = macro_f_state_t_initialize(fake_common_allocation_large_d, fake_common_allocation_small_d, 0, &fake_signal_state_interrupt_iki, 0, (void *) data_make->main, 0);
 
@@ -260,7 +257,7 @@ extern "C" {
 
       range = content.array[i];
 
-      *status = fl_iki_read(state, &data_make->buffer, &range, &iki_variable, &iki_vocabulary, &iki_content, &iki_delimits);
+      *status = fl_iki_read(state, &data_make->buffer, &range, &iki_data);
 
       if (F_status_is_error(*status)) {
         if (F_status_set_fine(*status) != F_interrupt) {
@@ -271,17 +268,17 @@ extern "C" {
       }
 
       // Apply the IKI delimits to the buffer.
-      for (j = 0; j < iki_delimits.used; ++j) {
-        data_make->buffer.string[iki_delimits.array[j]] = f_iki_syntax_placeholder_s.string[0];
+      for (j = 0; j < iki_data.delimits.used; ++j) {
+        data_make->buffer.string[iki_data.delimits.array[j]] = f_iki_syntax_placeholder_s.string[0];
       } // for
 
-      if (iki_variable.used) {
+      if (iki_data.variable.used) {
         used_content = arguments->array[arguments->used].used;
 
         // Copy everything up to the start of the first IKI variable.
-        if (iki_variable.array[0].start && content.array[i].start < iki_variable.array[0].start) {
+        if (iki_data.variable.array[0].start && content.array[i].start < iki_data.variable.array[0].start) {
           range.start = content.array[i].start;
-          range.stop = iki_variable.array[0].start - 1;
+          range.stop = iki_data.variable.array[0].start - 1;
 
           *status = f_string_dynamic_partial_append_nulless(data_make->buffer, range, &arguments->array[arguments->used]);
 
@@ -292,23 +289,23 @@ extern "C" {
           }
         }
 
-        for (j = 0; j < iki_variable.used; ++j) {
+        for (j = 0; j < iki_data.variable.used; ++j) {
 
           is = 0;
 
-          *status = fl_string_dynamic_partial_compare(vocabulary_define, data_make->buffer, range_define, iki_vocabulary.array[j]);
+          *status = fl_string_dynamic_partial_compare(vocabulary_define, data_make->buffer, range_define, iki_data.vocabulary.array[j]);
 
           if (*status == F_equal_to) {
             is = 2;
           }
           else if (*status == F_equal_to_not) {
-            *status = fl_string_dynamic_partial_compare(vocabulary_parameter, data_make->buffer, range_parameter, iki_vocabulary.array[j]);
+            *status = fl_string_dynamic_partial_compare(vocabulary_parameter, data_make->buffer, range_parameter, iki_data.vocabulary.array[j]);
 
             if (*status == F_equal_to) {
               is = 1;
             }
             else if (*status == F_equal_to_not) {
-              *status = fl_string_dynamic_partial_compare(vocabulary_context, data_make->buffer, range_context, iki_vocabulary.array[j]);
+              *status = fl_string_dynamic_partial_compare(vocabulary_context, data_make->buffer, range_context, iki_data.vocabulary.array[j]);
 
               if (*status == F_equal_to) {
                 is = 3;
@@ -326,7 +323,7 @@ extern "C" {
             unmatched = F_true;
 
             // Check against reserved parameter names and if matches use them instead.
-            if (fl_string_dynamic_partial_compare_string(fake_make_parameter_variable_return_s.string, data_make->buffer, fake_make_parameter_variable_return_s.used, iki_content.array[j]) == F_equal_to) {
+            if (fl_string_dynamic_partial_compare_string(fake_make_parameter_variable_return_s.string, data_make->buffer, fake_make_parameter_variable_return_s.used, iki_data.content.array[j]) == F_equal_to) {
               if (data_make->setting_make.parameter.array[0].value.array[0].used) {
                 *status = f_string_dynamic_append_nulless(data_make->setting_make.parameter.array[0].value.array[0], &arguments->array[arguments->used]);
 
@@ -351,7 +348,7 @@ extern "C" {
             else {
               for (k = 0; k < 33; ++k) {
 
-                if (fl_string_dynamic_partial_compare_string(reserved_name[k].string, data_make->buffer, reserved_name[k].used, iki_content.array[j]) != F_equal_to) {
+                if (fl_string_dynamic_partial_compare_string(reserved_name[k].string, data_make->buffer, reserved_name[k].used, iki_data.content.array[j]) != F_equal_to) {
                   continue;
                 }
 
@@ -398,7 +395,7 @@ extern "C" {
               for (k = 0; k < parameter->used; ++k) {
 
                 // Check against IKI variable list.
-                *status = fl_string_dynamic_partial_compare_dynamic(parameter->array[k].name, data_make->buffer, iki_content.array[j]);
+                *status = fl_string_dynamic_partial_compare_dynamic(parameter->array[k].name, data_make->buffer, iki_data.content.array[j]);
 
                 if (*status == F_equal_to) {
                   unmatched = F_false;
@@ -461,7 +458,7 @@ extern "C" {
             if (F_status_is_error(*status)) break;
 
             if (unmatched) {
-              *status = fake_make_operate_expand_build(data_make, quotes.array[i], iki_content.array[j], arguments);
+              *status = fake_make_operate_expand_build(data_make, quotes.array[i], iki_data.content.array[j], arguments);
 
               if (F_status_is_error(*status)) {
                 fll_error_print(data_make->error, F_status_set_fine(*status), "fake_make_operate_expand_build", F_true);
@@ -472,7 +469,7 @@ extern "C" {
           }
           else if (is == 2) {
             if (data_make->setting_make.load_build) {
-              *status = fake_make_operate_expand_environment(data_make, quotes.array[i], iki_content.array[j], arguments);
+              *status = fake_make_operate_expand_environment(data_make, quotes.array[i], iki_data.content.array[j], arguments);
 
               if (F_status_is_error(*status)) {
                 fll_error_print(data_make->error, F_status_set_fine(*status), "fake_make_operate_expand_environment", F_true);
@@ -482,7 +479,7 @@ extern "C" {
             }
           }
           else if (is == 3) {
-            *status = fake_make_operate_expand_context(data_make, quotes.array[i], iki_content.array[j], arguments);
+            *status = fake_make_operate_expand_context(data_make, quotes.array[i], iki_data.content.array[j], arguments);
 
             if (F_status_is_error(*status)) {
               fll_error_print(data_make->error, F_status_set_fine(*status), "fake_make_operate_expand_context", F_true);
@@ -492,10 +489,10 @@ extern "C" {
           }
 
           // Make sure to copy and content between multiple IKI variables within the same content.
-          if (j + 1 < iki_variable.used) {
-            if (iki_variable.array[j].stop + 1 < iki_variable.array[j + 1].start && iki_variable.array[j + 1].stop <= content.array[i].stop) {
-              range.start = iki_variable.array[j].stop + 1;
-              range.stop = iki_variable.array[j + 1].start - 1;
+          if (j + 1 < iki_data.variable.used) {
+            if (iki_data.variable.array[j].stop + 1 < iki_data.variable.array[j + 1].start && iki_data.variable.array[j + 1].stop <= content.array[i].stop) {
+              range.start = iki_data.variable.array[j].stop + 1;
+              range.stop = iki_data.variable.array[j + 1].start - 1;
 
               *status = f_string_dynamic_partial_append_nulless(data_make->buffer, range, &arguments->array[arguments->used]);
 
@@ -509,8 +506,8 @@ extern "C" {
         } // for
 
         // Copy everything after the last IKI variable to the end of the content.
-        if (iki_variable.used && content.array[i].stop > iki_variable.array[iki_variable.used - 1].stop) {
-          range.start = iki_variable.array[iki_variable.used - 1].stop + 1;
+        if (iki_data.variable.used && content.array[i].stop > iki_data.variable.array[iki_data.variable.used - 1].stop) {
+          range.start = iki_data.variable.array[iki_data.variable.used - 1].stop + 1;
           range.stop = content.array[i].stop;
 
           *status = f_string_dynamic_partial_append_nulless(data_make->buffer, range, &arguments->array[arguments->used]);
@@ -539,16 +536,10 @@ extern "C" {
         ++arguments->used;
       }
 
-      macro_f_iki_variable_t_delete_simple(iki_variable);
-      macro_f_iki_vocabulary_t_delete_simple(iki_vocabulary);
-      macro_f_iki_content_t_delete_simple(iki_content);
-      macro_f_iki_delimits_t_delete_simple(iki_delimits);
+      f_iki_data_delete(&iki_data);
     } // for
 
-    macro_f_iki_variable_t_delete_simple(iki_variable);
-    macro_f_iki_vocabulary_t_delete_simple(iki_vocabulary);
-    macro_f_iki_content_t_delete_simple(iki_content);
-    macro_f_iki_delimits_t_delete_simple(iki_delimits);
+    f_iki_data_delete(&iki_data);
   }
 #endif // _di_fake_make_operate_expand_
 
diff --git a/level_3/iki_read/c/private-common.h b/level_3/iki_read/c/private-common.h
index 3ca90d2..97a8d17 100644
--- a/level_3/iki_read/c/private-common.h
+++ b/level_3/iki_read/c/private-common.h
@@ -25,38 +25,6 @@ extern "C" {
 #endif // _di_iki_read_common_
 
 /**
- * Provide a structure for containing processed IKI data.
- *
- * variable:   The variable ranges.
- * vocabulary: The vocabulary ranges.
- * content:    The content ranges.
- * delimits:   The delimited locations.
- */
-#ifndef _di_iki_data_
-  typedef struct {
-    f_iki_variable_t variable;
-    f_iki_vocabulary_t vocabulary;
-    f_iki_content_t content;
-    f_iki_delimits_t delimits;
-  } iki_data_t;
-
-  #define iki_data_t_initialize \
-    { \
-      f_iki_variable_t_initialize, \
-      f_iki_vocabulary_t_initialize, \
-      f_iki_content_t_initialize, \
-      f_iki_delimits_t_initialize, \
-    }
-
-  #define macro_iki_data_t_delete_simple(data) \
-    macro_f_iki_variable_t_delete_simple(data.variable) \
-    macro_f_iki_vocabulary_t_delete_simple(data.vocabulary) \
-    macro_f_iki_content_t_delete_simple(data.content) \
-    macro_f_iki_delimits_t_delete_simple(data.delimits)
-
-#endif // _di_iki_data_
-
-/**
  * Print a message about a process signal being recieved, such as an interrupt signal.
  *
  * @param main
diff --git a/level_3/iki_read/c/private-print.c b/level_3/iki_read/c/private-print.c
index a268364..eabeb71 100644
--- a/level_3/iki_read/c/private-print.c
+++ b/level_3/iki_read/c/private-print.c
@@ -7,7 +7,7 @@ extern "C" {
 #endif
 
 #ifndef _di_iki_read_substitutions_print_
-  void iki_read_substitutions_print(iki_read_main_t * const main, const iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) {
+  void iki_read_substitutions_print(iki_read_main_t * const main, const f_iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) {
 
     f_status_t status = F_none;
     f_array_length_t i = 0;
diff --git a/level_3/iki_read/c/private-print.h b/level_3/iki_read/c/private-print.h
index bda54fb..205ffe8 100644
--- a/level_3/iki_read/c/private-print.h
+++ b/level_3/iki_read/c/private-print.h
@@ -30,7 +30,7 @@ extern "C" {
  *   Set to FALSE to print the entire variable when printing substituted text.
  */
 #ifndef _di_iki_read_substitutions_print_
-  extern void iki_read_substitutions_print(iki_read_main_t * const main, const iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) F_attribute_visibility_internal_d;
+  extern void iki_read_substitutions_print(iki_read_main_t * const main, const f_iki_data_t iki_data, const f_string_ranges_t ranges, const iki_read_substitutions_t substitutions, const f_array_length_t index, const bool content_only) F_attribute_visibility_internal_d;
 #endif // _di_iki_read_substitutions_print_
 
 #ifdef __cplusplus
diff --git a/level_3/iki_read/c/private-read.c b/level_3/iki_read/c/private-read.c
index 7e3b3a8..f126463 100644
--- a/level_3/iki_read/c/private-read.c
+++ b/level_3/iki_read/c/private-read.c
@@ -39,7 +39,7 @@ extern "C" {
   f_status_t iki_read_process_buffer(iki_read_main_t * const main) {
 
     f_status_t status = F_none;
-    iki_data_t iki_data = iki_data_t_initialize;
+    f_iki_data_t iki_data = f_iki_data_t_initialize;
 
     if (main->parameters.array[iki_read_parameter_whole_e].result == f_console_result_found_e) {
       f_string_range_t buffer_range = macro_f_string_range_t_initialize(main->buffer.used);
@@ -74,7 +74,7 @@ extern "C" {
       status = iki_read_process_at(main, &buffer_range);
 
       if (status == F_true && buffer_range.start > main->buffer.used || status == F_data_not) {
-        macro_iki_data_t_delete_simple(iki_data);
+        f_iki_data_delete(&iki_data);
 
         return F_data_not;
       }
@@ -90,14 +90,14 @@ extern "C" {
       }
     }
 
-    macro_iki_data_t_delete_simple(iki_data);
+    f_iki_data_delete(&iki_data);
 
     return status;
   }
 #endif // _di_iki_read_process_buffer_
 
 #ifndef _di_iki_read_process_buffer_ranges_
-  f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) {
+  f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) {
 
     f_status_t status = F_none;
 
@@ -106,7 +106,7 @@ extern "C" {
     {
       f_state_t state = macro_f_state_t_initialize(iki_read_common_allocation_large_d, iki_read_common_allocation_small_d, 0, 0, 0, 0, 0);
 
-      status = fl_iki_read(state, &main->buffer, buffer_range, &iki_data->variable, &iki_data->vocabulary, &iki_data->content, &iki_data->delimits);
+      status = fl_iki_read(state, &main->buffer, buffer_range, iki_data);
     }
 
     if (F_status_is_error(status)) {
@@ -259,7 +259,7 @@ extern "C" {
 #endif // _di_iki_read_process_buffer_ranges_
 
 #ifndef _di_iki_read_process_buffer_ranges_whole_
-  f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) {
+  f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) {
 
     f_status_t status = F_none;
     f_string_range_t range = buffer_range;
@@ -267,7 +267,7 @@ extern "C" {
     {
       f_state_t state = macro_f_state_t_initialize(iki_read_common_allocation_large_d, iki_read_common_allocation_small_d, 0, 0, 0, 0, 0);
 
-      status = fl_iki_read(state, &main->buffer, &range, &iki_data->variable, &iki_data->vocabulary, &iki_data->content, &iki_data->delimits);
+      status = fl_iki_read(state, &main->buffer, &range, iki_data);
     }
 
     if (F_status_is_error(status)) {
@@ -451,7 +451,7 @@ extern "C" {
 #endif // _di_iki_read_process_buffer_ranges_whole_
 
 #ifndef _di_iki_read_process_buffer_total_
-  f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, iki_data_t *iki_data) {
+  f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, f_iki_data_t *iki_data) {
 
     f_status_t status = F_none;
     f_string_range_t range = macro_f_string_range_t_initialize(main->buffer.used);
@@ -474,7 +474,7 @@ extern "C" {
     {
       f_state_t state = macro_f_state_t_initialize(iki_read_common_allocation_large_d, iki_read_common_allocation_small_d, 0, 0, 0, 0, 0);
 
-      status = fl_iki_read(state, &main->buffer, &range, &iki_data->variable, &iki_data->vocabulary, &iki_data->content, &iki_data->delimits);
+      status = fl_iki_read(state, &main->buffer, &range, iki_data);
     }
 
     if (F_status_is_error(status)) {
diff --git a/level_3/iki_read/c/private-read.h b/level_3/iki_read/c/private-read.h
index 71348e5..1c87a43 100644
--- a/level_3/iki_read/c/private-read.h
+++ b/level_3/iki_read/c/private-read.h
@@ -70,7 +70,7 @@ extern "C" {
  *   Status codes (with error bit) are returned on any problem.
  */
 #ifndef _di_iki_read_process_buffer_ranges_
-  extern f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d;
+  extern f_status_t iki_read_process_buffer_ranges(iki_read_main_t * const main, f_string_range_t *buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d;
 #endif // _di_iki_read_process_buffer_ranges_
 
 /**
@@ -95,7 +95,7 @@ extern "C" {
  *   Status codes (with error bit) are returned on any problem.
  */
 #ifndef _di_iki_read_process_buffer_ranges_whole_
-  extern f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d;
+  extern f_status_t iki_read_process_buffer_ranges_whole(iki_read_main_t * const main, const f_string_range_t buffer_range, f_iki_data_t *iki_data, f_string_ranges_t *ranges) F_attribute_visibility_internal_d;
 #endif // _di_iki_read_process_buffer_ranges_whole_
 
 /**
@@ -112,7 +112,7 @@ extern "C" {
  *   Status codes (with error bit) are returned on any problem.
  */
 #ifndef _di_iki_read_process_buffer_total_
-  extern f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, iki_data_t *iki_data) F_attribute_visibility_internal_d;
+  extern f_status_t iki_read_process_buffer_total(iki_read_main_t * const main, f_iki_data_t *iki_data) F_attribute_visibility_internal_d;
 #endif // _di_iki_read_process_buffer_total_
 
 /**