From 8121e3aff8355bbd4df54e578c6f549caf928368 Mon Sep 17 00:00:00 2001
From: Kevin Day <thekevinday@gmail.com>
Date: Thu, 3 Dec 2020 23:22:37 -0600
Subject: [PATCH] Cleanup: the fl_type functions should have "_type".

I completely overlooked this.
To follow the correct practice, make sure that "_type" is on each function.
---
 level_1/fl_type/c/type.c | 240 +++++++++++++++++++++++------------------------
 level_1/fl_type/c/type.h | 240 +++++++++++++++++++++++------------------------
 2 files changed, 240 insertions(+), 240 deletions(-)

diff --git a/level_1/fl_type/c/type.c b/level_1/fl_type/c/type.c
index 114df51..a04b61f 100644
--- a/level_1/fl_type/c/type.c
+++ b/level_1/fl_type/c/type.c
@@ -4,8 +4,8 @@
 extern "C" {
 #endif
 
-#ifndef _di_fl_cells_increase_
-  f_return_status fl_cells_increase(f_cells_t *cells) {
+#ifndef _di_fl_type_cells_increase_
+  f_return_status fl_type_cells_increase(f_cells_t *cells) {
 
     if (cells->used + 1 > cells->size) {
       f_array_length_t size = cells->used + f_memory_default_allocation_step;
@@ -27,10 +27,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_cells_increase_
+#endif // _di_fl_type_cells_increase_
 
-#ifndef _di_fl_cells_increase_by_
-  f_return_status fl_cells_increase_by(const f_array_length_t amount, f_cells_t *cells) {
+#ifndef _di_fl_type_cells_increase_by_
+  f_return_status fl_type_cells_increase_by(const f_array_length_t amount, f_cells_t *cells) {
 
     if (cells->used + amount > cells->size) {
       if (cells->used + amount > f_array_length_t_size) {
@@ -46,10 +46,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_cells_increase_by_
+#endif // _di_fl_type_cells_increase_by_
 
-#ifndef _di_fl_cellss_increase_
-  f_return_status fl_cellss_increase(f_cellss_t *cellss) {
+#ifndef _di_fl_type_cellss_increase_
+  f_return_status fl_type_cellss_increase(f_cellss_t *cellss) {
 
     if (cellss->used + 1 > cellss->size) {
       f_array_length_t size = cellss->used + f_memory_default_allocation_step;
@@ -71,10 +71,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_cellss_increase_
+#endif // _di_fl_type_cellss_increase_
 
-#ifndef _di_fl_cellss_increase_by_
-  f_return_status fl_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss) {
+#ifndef _di_fl_type_cellss_increase_by_
+  f_return_status fl_type_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss) {
 
     if (cellss->used + amount > cellss->size) {
       if (cellss->used + amount > f_array_length_t_size) {
@@ -90,10 +90,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_cellss_increase_by_
+#endif // _di_fl_type_cellss_increase_by_
 
-#ifndef _di_fl_array_lengths_increase_
-  f_return_status fl_array_lengths_increase(f_array_lengths_t *lengths) {
+#ifndef _di_fl_type_array_lengths_increase_
+  f_return_status fl_type_array_lengths_increase(f_array_lengths_t *lengths) {
 
     if (lengths->used + 1 > lengths->size) {
       f_array_length_t size = lengths->used + f_memory_default_allocation_step;
@@ -115,10 +115,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_array_lengths_increase_
+#endif // _di_fl_type_array_lengths_increase_
 
-#ifndef _di_fl_array_lengths_increase_by_
-  f_return_status fl_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
+#ifndef _di_fl_type_array_lengths_increase_by_
+  f_return_status fl_type_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *lengths) {
 
     if (lengths->used + amount > lengths->size) {
       if (lengths->used + amount > f_array_length_t_size) {
@@ -134,10 +134,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_array_lengths_increase_by_
+#endif // _di_fl_type_array_lengths_increase_by_
 
-#ifndef _di_fl_array_lengthss_increase_
-  f_return_status fl_array_lengthss_increase(f_array_lengthss_t *lengthss) {
+#ifndef _di_fl_type_array_lengthss_increase_
+  f_return_status fl_type_array_lengthss_increase(f_array_lengthss_t *lengthss) {
 
     if (lengthss->used + 1 > lengthss->size) {
       f_array_length_t size = lengthss->used + f_memory_default_allocation_step;
@@ -159,10 +159,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_array_lengthss_increase_
+#endif // _di_fl_type_array_lengthss_increase_
 
-#ifndef _di_fl_array_lengthss_increase_by_
-  f_return_status fl_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
+#ifndef _di_fl_type_array_lengthss_increase_by_
+  f_return_status fl_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *lengthss) {
 
     if (lengthss->used + amount > lengthss->size) {
       if (lengthss->used + amount > f_array_length_t_size) {
@@ -178,10 +178,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_array_lengthss_increase_by_
+#endif // _di_fl_type_array_lengthss_increase_by_
 
-#ifndef _di_fl_int8s_increase_
-  f_return_status fl_int8s_increase(f_int8s_t *int8s) {
+#ifndef _di_fl_type_int8s_increase_
+  f_return_status fl_type_int8s_increase(f_int8s_t *int8s) {
 
     if (int8s->used + 1 > int8s->size) {
       f_array_length_t size = int8s->used + f_memory_default_allocation_step;
@@ -203,10 +203,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int8s_increase_
+#endif // _di_fl_type_int8s_increase_
 
-#ifndef _di_fl_int8s_increase_by_
-  f_return_status fl_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s) {
+#ifndef _di_fl_type_int8s_increase_by_
+  f_return_status fl_type_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s) {
 
     if (int8s->used + amount > int8s->size) {
       if (int8s->used + amount > f_array_length_t_size) {
@@ -222,10 +222,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int8s_increase_by_
+#endif // _di_fl_type_int8s_increase_by_
 
-#ifndef _di_fl_int8ss_increase_
-  f_return_status fl_int8ss_increase(f_int8ss_t *int8ss) {
+#ifndef _di_fl_type_int8ss_increase_
+  f_return_status fl_type_int8ss_increase(f_int8ss_t *int8ss) {
 
     if (int8ss->used + 1 > int8ss->size) {
       f_array_length_t size = int8ss->used + f_memory_default_allocation_step;
@@ -247,10 +247,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int8ss_increase_
+#endif // _di_fl_type_int8ss_increase_
 
-#ifndef _di_fl_int8ss_increase_by_
-  f_return_status fl_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
+#ifndef _di_fl_type_int8ss_increase_by_
+  f_return_status fl_type_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss) {
 
     if (int8ss->used + amount > int8ss->size) {
       if (int8ss->used + amount > f_array_length_t_size) {
@@ -266,10 +266,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int8ss_increase_by_
+#endif // _di_fl_type_int8ss_increase_by_
 
-#ifndef _di_fl_uint8s_increase_
-  f_return_status fl_uint8s_increase(f_uint8s_t *uint8s) {
+#ifndef _di_fl_type_uint8s_increase_
+  f_return_status fl_type_uint8s_increase(f_uint8s_t *uint8s) {
 
     if (uint8s->used + 1 > uint8s->size) {
       f_array_length_t size = uint8s->used + f_memory_default_allocation_step;
@@ -291,10 +291,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint8s_increase_
+#endif // _di_fl_type_uint8s_increase_
 
-#ifndef _di_fl_uint8s_increase_by_
-  f_return_status fl_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
+#ifndef _di_fl_type_uint8s_increase_by_
+  f_return_status fl_type_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s) {
 
     if (uint8s->used + amount > uint8s->size) {
       if (uint8s->used + amount > f_array_length_t_size) {
@@ -310,10 +310,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint8s_increase_by_
+#endif // _di_fl_type_uint8s_increase_by_
 
-#ifndef _di_fl_uint8ss_increase_
-  f_return_status fl_uint8ss_increase(f_uint8ss_t *uint8ss) {
+#ifndef _di_fl_type_uint8ss_increase_
+  f_return_status fl_type_uint8ss_increase(f_uint8ss_t *uint8ss) {
 
     if (uint8ss->used + 1 > uint8ss->size) {
       f_array_length_t size = uint8ss->used + f_memory_default_allocation_step;
@@ -335,10 +335,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint8ss_increase_
+#endif // _di_fl_type_uint8ss_increase_
 
-#ifndef _di_fl_uint8ss_increase_by_
-  f_return_status fl_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
+#ifndef _di_fl_type_uint8ss_increase_by_
+  f_return_status fl_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss) {
 
     if (uint8ss->used + amount > uint8ss->size) {
       if (uint8ss->used + amount > f_array_length_t_size) {
@@ -354,10 +354,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint8ss_increase_by_
+#endif // _di_fl_type_uint8ss_increase_by_
 
-#ifndef _di_fl_int16s_increase_
-  f_return_status fl_int16s_increase(f_int16s_t *int16s) {
+#ifndef _di_fl_type_int16s_increase_
+  f_return_status fl_type_int16s_increase(f_int16s_t *int16s) {
 
     if (int16s->used + 1 > int16s->size) {
       f_array_length_t size = int16s->used + f_memory_default_allocation_step;
@@ -379,10 +379,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int16s_increase_
+#endif // _di_fl_type_int16s_increase_
 
-#ifndef _di_fl_int16s_increase_by_
-  f_return_status fl_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s) {
+#ifndef _di_fl_type_int16s_increase_by_
+  f_return_status fl_type_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s) {
 
     if (int16s->used + amount > int16s->size) {
       if (int16s->used + amount > f_array_length_t_size) {
@@ -398,10 +398,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int16s_increase_by_
+#endif // _di_fl_type_int16s_increase_by_
 
-#ifndef _di_fl_int16ss_increase_
-  f_return_status fl_int16ss_increase(f_int16ss_t *int16ss) {
+#ifndef _di_fl_type_int16ss_increase_
+  f_return_status fl_type_int16ss_increase(f_int16ss_t *int16ss) {
 
     if (int16ss->used + 1 > int16ss->size) {
       f_array_length_t size = int16ss->used + f_memory_default_allocation_step;
@@ -423,10 +423,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int16ss_increase_
+#endif // _di_fl_type_int16ss_increase_
 
-#ifndef _di_fl_int16ss_increase_by_
-  f_return_status fl_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
+#ifndef _di_fl_type_int16ss_increase_by_
+  f_return_status fl_type_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss) {
 
     if (int16ss->used + amount > int16ss->size) {
       if (int16ss->used + amount > f_array_length_t_size) {
@@ -442,10 +442,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int16ss_increase_by_
+#endif // _di_fl_type_int16ss_increase_by_
 
-#ifndef _di_fl_uint16s_increase_
-  f_return_status fl_uint16s_increase(f_uint16s_t *uint16s) {
+#ifndef _di_fl_type_uint16s_increase_
+  f_return_status fl_type_uint16s_increase(f_uint16s_t *uint16s) {
 
     if (uint16s->used + 1 > uint16s->size) {
       f_array_length_t size = uint16s->used + f_memory_default_allocation_step;
@@ -467,10 +467,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint16s_increase_
+#endif // _di_fl_type_uint16s_increase_
 
-#ifndef _di_fl_uint16s_increase_by_
-  f_return_status fl_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
+#ifndef _di_fl_type_uint16s_increase_by_
+  f_return_status fl_type_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s) {
 
     if (uint16s->used + amount > uint16s->size) {
       if (uint16s->used + amount > f_array_length_t_size) {
@@ -486,10 +486,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint16s_increase_by_
+#endif // _di_fl_type_uint16s_increase_by_
 
-#ifndef _di_fl_uint16ss_increase_
-  f_return_status fl_uint16ss_increase(f_uint16ss_t *uint16ss) {
+#ifndef _di_fl_type_uint16ss_increase_
+  f_return_status fl_type_uint16ss_increase(f_uint16ss_t *uint16ss) {
 
     if (uint16ss->used + 1 > uint16ss->size) {
       f_array_length_t size = uint16ss->used + f_memory_default_allocation_step;
@@ -511,10 +511,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint16ss_increase_
+#endif // _di_fl_type_uint16ss_increase_
 
-#ifndef _di_fl_uint16ss_increase_by_
-  f_return_status fl_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
+#ifndef _di_fl_type_uint16ss_increase_by_
+  f_return_status fl_type_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss) {
 
     if (uint16ss->used + amount > uint16ss->size) {
       if (uint16ss->used + amount > f_array_length_t_size) {
@@ -530,10 +530,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint16ss_increase_by_
+#endif // _di_fl_type_uint16ss_increase_by_
 
-#ifndef _di_fl_int32s_increase_
-  f_return_status fl_int32s_increase(f_int32s_t *int32s) {
+#ifndef _di_fl_type_int32s_increase_
+  f_return_status fl_type_int32s_increase(f_int32s_t *int32s) {
 
     if (int32s->used + 1 > int32s->size) {
       f_array_length_t size = int32s->used + f_memory_default_allocation_step;
@@ -555,10 +555,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int32s_increase_
+#endif // _di_fl_type_int32s_increase_
 
-#ifndef _di_fl_int32s_increase_by_
-  f_return_status fl_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s) {
+#ifndef _di_fl_type_int32s_increase_by_
+  f_return_status fl_type_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s) {
 
     if (int32s->used + amount > int32s->size) {
       if (int32s->used + amount > f_array_length_t_size) {
@@ -574,10 +574,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int32s_increase_by_
+#endif // _di_fl_type_int32s_increase_by_
 
-#ifndef _di_fl_int32ss_increase_
-  f_return_status fl_int32ss_increase(f_int32ss_t *int32ss) {
+#ifndef _di_fl_type_int32ss_increase_
+  f_return_status fl_type_int32ss_increase(f_int32ss_t *int32ss) {
 
     if (int32ss->used + 1 > int32ss->size) {
       f_array_length_t size = int32ss->used + f_memory_default_allocation_step;
@@ -599,10 +599,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int32ss_increase_
+#endif // _di_fl_type_int32ss_increase_
 
-#ifndef _di_fl_int32ss_increase_by_
-  f_return_status fl_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
+#ifndef _di_fl_type_int32ss_increase_by_
+  f_return_status fl_type_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss) {
 
     if (int32ss->used + amount > int32ss->size) {
       if (int32ss->used + amount > f_array_length_t_size) {
@@ -618,10 +618,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int32ss_increase_by_
+#endif // _di_fl_type_int32ss_increase_by_
 
-#ifndef _di_fl_uint32s_increase_
-  f_return_status fl_uint32s_increase(f_uint32s_t *uint32s) {
+#ifndef _di_fl_type_uint32s_increase_
+  f_return_status fl_type_uint32s_increase(f_uint32s_t *uint32s) {
 
     if (uint32s->used + 1 > uint32s->size) {
       f_array_length_t size = uint32s->used + f_memory_default_allocation_step;
@@ -643,10 +643,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint32s_increase_
+#endif // _di_fl_type_uint32s_increase_
 
-#ifndef _di_fl_uint32s_increase_by_
-  f_return_status fl_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
+#ifndef _di_fl_type_uint32s_increase_by_
+  f_return_status fl_type_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s) {
 
     if (uint32s->used + amount > uint32s->size) {
       if (uint32s->used + amount > f_array_length_t_size) {
@@ -662,10 +662,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint32s_increase_by_
+#endif // _di_fl_type_uint32s_increase_by_
 
-#ifndef _di_fl_uint32ss_increase_
-  f_return_status fl_uint32ss_increase(f_uint32ss_t *uint32ss) {
+#ifndef _di_fl_type_uint32ss_increase_
+  f_return_status fl_type_uint32ss_increase(f_uint32ss_t *uint32ss) {
 
     if (uint32ss->used + 1 > uint32ss->size) {
       f_array_length_t size = uint32ss->used + f_memory_default_allocation_step;
@@ -687,10 +687,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint32ss_increase_
+#endif // _di_fl_type_uint32ss_increase_
 
-#ifndef _di_fl_uint32ss_increase_by_
-  f_return_status fl_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
+#ifndef _di_fl_type_uint32ss_increase_by_
+  f_return_status fl_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss) {
 
     if (uint32ss->used + amount > uint32ss->size) {
       if (uint32ss->used + amount > f_array_length_t_size) {
@@ -706,7 +706,7 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint32ss_increase_by_
+#endif // _di_fl_type_uint32ss_increase_by_
 
 #ifndef _di_fl_int64s_increase_
   f_return_status fl_int64s_increase(f_int64s_t *int64s) {
@@ -884,8 +884,8 @@ extern "C" {
   }
 #endif // _di_fl_uint64ss_increase_by_
 
-#ifndef _di_fl_int128s_increase_
-  f_return_status fl_int128s_increase(f_int128s_t *int128s) {
+#ifndef _di_fl_type_int128s_increase_
+  f_return_status fl_type_int128s_increase(f_int128s_t *int128s) {
 
     if (int128s->used + 1 > int128s->size) {
       f_array_length_t size = int128s->used + f_memory_default_allocation_step;
@@ -907,10 +907,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int128s_increase_
+#endif // _di_fl_type_int128s_increase_
 
-#ifndef _di_fl_int128s_increase_by_
-  f_return_status fl_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s) {
+#ifndef _di_fl_type_int128s_increase_by_
+  f_return_status fl_type_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s) {
 
     if (int128s->used + amount > int128s->size) {
       if (int128s->used + amount > f_array_length_t_size) {
@@ -926,10 +926,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int128s_increase_by_
+#endif // _di_fl_type_int128s_increase_by_
 
-#ifndef _di_fl_int128ss_increase_
-  f_return_status fl_int128ss_increase(f_int128ss_t *int128ss) {
+#ifndef _di_fl_type_int128ss_increase_
+  f_return_status fl_type_int128ss_increase(f_int128ss_t *int128ss) {
 
     if (int128ss->used + 1 > int128ss->size) {
       f_array_length_t size = int128ss->used + f_memory_default_allocation_step;
@@ -951,10 +951,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int128ss_increase_
+#endif // _di_fl_type_int128ss_increase_
 
-#ifndef _di_fl_int128ss_increase_by_
-  f_return_status fl_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
+#ifndef _di_fl_type_int128ss_increase_by_
+  f_return_status fl_type_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss) {
 
     if (int128ss->used + amount > int128ss->size) {
       if (int128ss->used + amount > f_array_length_t_size) {
@@ -970,10 +970,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_int128ss_increase_by_
+#endif // _di_fl_type_int128ss_increase_by_
 
-#ifndef _di_fl_uint128s_increase_
-  f_return_status fl_uint128s_increase(f_uint128s_t *uint128s) {
+#ifndef _di_fl_type_uint128s_increase_
+  f_return_status fl_type_uint128s_increase(f_uint128s_t *uint128s) {
 
     if (uint128s->used + 1 > uint128s->size) {
       f_array_length_t size = uint128s->used + f_memory_default_allocation_step;
@@ -995,10 +995,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint128s_increase_
+#endif // _di_fl_type_uint128s_increase_
 
-#ifndef _di_fl_uint128s_increase_by_
-  f_return_status fl_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
+#ifndef _di_fl_type_uint128s_increase_by_
+  f_return_status fl_type_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s) {
 
     if (uint128s->used + amount > uint128s->size) {
       if (uint128s->used + amount > f_array_length_t_size) {
@@ -1014,10 +1014,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint128s_increase_by_
+#endif // _di_fl_type_uint128s_increase_by_
 
-#ifndef _di_fl_uint128ss_increase_
-  f_return_status fl_uint128ss_increase(f_uint128ss_t *uint128ss) {
+#ifndef _di_fl_type_uint128ss_increase_
+  f_return_status fl_type_uint128ss_increase(f_uint128ss_t *uint128ss) {
 
     if (uint128ss->used + 1 > uint128ss->size) {
       f_array_length_t size = uint128ss->used + f_memory_default_allocation_step;
@@ -1039,10 +1039,10 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint128ss_increase_
+#endif // _di_fl_type_uint128ss_increase_
 
-#ifndef _di_fl_uint128ss_increase_by_
-  f_return_status fl_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
+#ifndef _di_fl_type_uint128ss_increase_by_
+  f_return_status fl_type_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss) {
 
     if (uint128ss->used + amount > uint128ss->size) {
       if (uint128ss->used + amount > f_array_length_t_size) {
@@ -1058,7 +1058,7 @@ extern "C" {
 
     return F_none;
   }
-#endif // _di_fl_uint128ss_increase_by_
+#endif // _di_fl_type_uint128ss_increase_by_
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/level_1/fl_type/c/type.h b/level_1/fl_type/c/type.h
index dcfcc81..15d872e 100644
--- a/level_1/fl_type/c/type.h
+++ b/level_1/fl_type/c/type.h
@@ -33,9 +33,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_cells_increase_
-  extern f_return_status fl_cells_increase(f_cells_t *cells) ;
-#endif // _di_fl_cells_increase_
+#ifndef _di_fl_type_cells_increase_
+  extern f_return_status fl_type_cells_increase(f_cells_t *cells) ;
+#endif // _di_fl_type_cells_increase_
 
 /**
  * Increase the size of cells array by the given amount, but only if necessary.
@@ -50,9 +50,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_cells_increase_by_
-  extern f_return_status fl_cells_increase_by(const f_array_length_t amount, f_cells_t *cells);
-#endif // _di_fl_cells_increase_by_
+#ifndef _di_fl_type_cells_increase_by_
+  extern f_return_status fl_type_cells_increase_by(const f_array_length_t amount, f_cells_t *cells);
+#endif // _di_fl_type_cells_increase_by_
 
 /**
  * Increase the size of cells array, but only if necessary.
@@ -65,9 +65,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_cellss_increase_
-  extern f_return_status fl_cellss_increase(f_cellss_t *cellss);
-#endif // _di_fl_cellss_increase_
+#ifndef _di_fl_type_cellss_increase_
+  extern f_return_status fl_type_cellss_increase(f_cellss_t *cellss);
+#endif // _di_fl_type_cellss_increase_
 
 /**
  * Increase the size of cellss array by the given amount, but only if necessary.
@@ -82,9 +82,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_cellss_increase_by_
-  extern f_return_status fl_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss);
-#endif // _di_fl_cellss_increase_by_
+#ifndef _di_fl_type_cellss_increase_by_
+  extern f_return_status fl_type_cellss_increase_by(const f_array_length_t amount, f_cellss_t *cellss);
+#endif // _di_fl_type_cellss_increase_by_
 
 /**
  * Increase the size of array_lengths array, but only if necessary.
@@ -97,9 +97,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_array_lengths_increase_
-  extern f_return_status fl_array_lengths_increase(f_array_lengths_t *array_lengths) ;
-#endif // _di_fl_array_lengths_increase_
+#ifndef _di_fl_type_array_lengths_increase_
+  extern f_return_status fl_type_array_lengths_increase(f_array_lengths_t *array_lengths) ;
+#endif // _di_fl_type_array_lengths_increase_
 
 /**
  * Increase the size of array_lengths array by the given amount, but only if necessary.
@@ -114,9 +114,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_array_lengths_increase_by_
-  extern f_return_status fl_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *array_lengths);
-#endif // _di_fl_array_lengths_increase_by_
+#ifndef _di_fl_type_array_lengths_increase_by_
+  extern f_return_status fl_type_array_lengths_increase_by(const f_array_length_t amount, f_array_lengths_t *array_lengths);
+#endif // _di_fl_type_array_lengths_increase_by_
 
 /**
  * Increase the size of array_lengths array, but only if necessary.
@@ -129,9 +129,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_array_lengthss_increase_
-  extern f_return_status fl_array_lengthss_increase(f_array_lengthss_t *array_lengthss);
-#endif // _di_fl_array_lengthss_increase_
+#ifndef _di_fl_type_array_lengthss_increase_
+  extern f_return_status fl_type_array_lengthss_increase(f_array_lengthss_t *array_lengthss);
+#endif // _di_fl_type_array_lengthss_increase_
 
 /**
  * Increase the size of array_lengthss array by the given amount, but only if necessary.
@@ -146,9 +146,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_array_lengthss_increase_by_
-  extern f_return_status fl_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss);
-#endif // _di_fl_array_lengthss_increase_by_
+#ifndef _di_fl_type_array_lengthss_increase_by_
+  extern f_return_status fl_type_array_lengthss_increase_by(const f_array_length_t amount, f_array_lengthss_t *array_lengthss);
+#endif // _di_fl_type_array_lengthss_increase_by_
 
 /**
  * Increase the size of int8s array, but only if necessary.
@@ -161,9 +161,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int8s_increase_
-  extern f_return_status fl_int8s_increase(f_int8s_t *int8s) ;
-#endif // _di_fl_int8s_increase_
+#ifndef _di_fl_type_int8s_increase_
+  extern f_return_status fl_type_int8s_increase(f_int8s_t *int8s) ;
+#endif // _di_fl_type_int8s_increase_
 
 /**
  * Increase the size of int8s array by the given amount, but only if necessary.
@@ -178,9 +178,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int8s_increase_by_
-  extern f_return_status fl_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s);
-#endif // _di_fl_int8s_increase_by_
+#ifndef _di_fl_type_int8s_increase_by_
+  extern f_return_status fl_type_int8s_increase_by(const f_array_length_t amount, f_int8s_t *int8s);
+#endif // _di_fl_type_int8s_increase_by_
 
 /**
  * Increase the size of int8s array, but only if necessary.
@@ -193,9 +193,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int8ss_increase_
-  extern f_return_status fl_int8ss_increase(f_int8ss_t *int8ss);
-#endif // _di_fl_int8ss_increase_
+#ifndef _di_fl_type_int8ss_increase_
+  extern f_return_status fl_type_int8ss_increase(f_int8ss_t *int8ss);
+#endif // _di_fl_type_int8ss_increase_
 
 /**
  * Increase the size of int8ss array by the given amount, but only if necessary.
@@ -210,9 +210,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int8ss_increase_by_
-  extern f_return_status fl_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss);
-#endif // _di_fl_int8ss_increase_by_
+#ifndef _di_fl_type_int8ss_increase_by_
+  extern f_return_status fl_type_int8ss_increase_by(const f_array_length_t amount, f_int8ss_t *int8ss);
+#endif // _di_fl_type_int8ss_increase_by_
 
 /**
  * Increase the size of uint8s array, but only if necessary.
@@ -225,9 +225,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint8s_increase_
-  extern f_return_status fl_uint8s_increase(f_uint8s_t *uint8s) ;
-#endif // _di_fl_uint8s_increase_
+#ifndef _di_fl_type_uint8s_increase_
+  extern f_return_status fl_type_uint8s_increase(f_uint8s_t *uint8s) ;
+#endif // _di_fl_type_uint8s_increase_
 
 /**
  * Increase the size of uint8s array by the given amount, but only if necessary.
@@ -242,9 +242,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint8s_increase_by_
-  extern f_return_status fl_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s);
-#endif // _di_fl_uint8s_increase_by_
+#ifndef _di_fl_type_uint8s_increase_by_
+  extern f_return_status fl_type_uint8s_increase_by(const f_array_length_t amount, f_uint8s_t *uint8s);
+#endif // _di_fl_type_uint8s_increase_by_
 
 /**
  * Increase the size of uint8s array, but only if necessary.
@@ -257,9 +257,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint8ss_increase_
-  extern f_return_status fl_uint8ss_increase(f_uint8ss_t *uint8ss);
-#endif // _di_fl_uint8ss_increase_
+#ifndef _di_fl_type_uint8ss_increase_
+  extern f_return_status fl_type_uint8ss_increase(f_uint8ss_t *uint8ss);
+#endif // _di_fl_type_uint8ss_increase_
 
 /**
  * Increase the size of uint8ss array by the given amount, but only if necessary.
@@ -274,9 +274,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint8ss_increase_by_
-  extern f_return_status fl_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
-#endif // _di_fl_uint8ss_increase_by_
+#ifndef _di_fl_type_uint8ss_increase_by_
+  extern f_return_status fl_type_uint8ss_increase_by(const f_array_length_t amount, f_uint8ss_t *uint8ss);
+#endif // _di_fl_type_uint8ss_increase_by_
 
 /**
  * Increase the size of int16s array, but only if necessary.
@@ -289,9 +289,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int16s_increase_
-  extern f_return_status fl_int16s_increase(f_int16s_t *int16s) ;
-#endif // _di_fl_int16s_increase_
+#ifndef _di_fl_type_int16s_increase_
+  extern f_return_status fl_type_int16s_increase(f_int16s_t *int16s) ;
+#endif // _di_fl_type_int16s_increase_
 
 /**
  * Increase the size of int16s array by the given amount, but only if necessary.
@@ -306,9 +306,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int16s_increase_by_
-  extern f_return_status fl_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s);
-#endif // _di_fl_int16s_increase_by_
+#ifndef _di_fl_type_int16s_increase_by_
+  extern f_return_status fl_type_int16s_increase_by(const f_array_length_t amount, f_int16s_t *int16s);
+#endif // _di_fl_type_int16s_increase_by_
 
 /**
  * Increase the size of int16s array, but only if necessary.
@@ -321,9 +321,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int16ss_increase_
-  extern f_return_status fl_int16ss_increase(f_int16ss_t *int16ss);
-#endif // _di_fl_int16ss_increase_
+#ifndef _di_fl_type_int16ss_increase_
+  extern f_return_status fl_type_int16ss_increase(f_int16ss_t *int16ss);
+#endif // _di_fl_type_int16ss_increase_
 
 /**
  * Increase the size of int16ss array by the given amount, but only if necessary.
@@ -338,9 +338,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int16ss_increase_by_
-  extern f_return_status fl_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss);
-#endif // _di_fl_int16ss_increase_by_
+#ifndef _di_fl_type_int16ss_increase_by_
+  extern f_return_status fl_type_int16ss_increase_by(const f_array_length_t amount, f_int16ss_t *int16ss);
+#endif // _di_fl_type_int16ss_increase_by_
 
 /**
  * Increase the size of uint16s array, but only if necessary.
@@ -353,9 +353,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint16s_increase_
-  extern f_return_status fl_uint16s_increase(f_uint16s_t *uint16s) ;
-#endif // _di_fl_uint16s_increase_
+#ifndef _di_fl_type_uint16s_increase_
+  extern f_return_status fl_type_uint16s_increase(f_uint16s_t *uint16s) ;
+#endif // _di_fl_type_uint16s_increase_
 
 /**
  * Increase the size of uint16s array by the given amount, but only if necessary.
@@ -370,9 +370,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint16s_increase_by_
-  extern f_return_status fl_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s);
-#endif // _di_fl_uint16s_increase_by_
+#ifndef _di_fl_type_uint16s_increase_by_
+  extern f_return_status fl_type_uint16s_increase_by(const f_array_length_t amount, f_uint16s_t *uint16s);
+#endif // _di_fl_type_uint16s_increase_by_
 
 /**
  * Increase the size of uint16s array, but only if necessary.
@@ -385,9 +385,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint16ss_increase_
-  extern f_return_status fl_uint16ss_increase(f_uint16ss_t *uint16ss);
-#endif // _di_fl_uint16ss_increase_
+#ifndef _di_fl_type_uint16ss_increase_
+  extern f_return_status fl_type_uint16ss_increase(f_uint16ss_t *uint16ss);
+#endif // _di_fl_type_uint16ss_increase_
 
 /**
  * Increase the size of uint16ss array by the given amount, but only if necessary.
@@ -402,9 +402,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint16ss_increase_by_
-  extern f_return_status fl_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
-#endif // _di_fl_uint16ss_increase_by_
+#ifndef _di_fl_type_uint16ss_increase_by_
+  extern f_return_status fl_type_uint16ss_increase_by(const f_array_length_t amount, f_uint16ss_t *uint16ss);
+#endif // _di_fl_type_uint16ss_increase_by_
 
 /**
  * Increase the size of int32s array, but only if necessary.
@@ -417,9 +417,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int32s_increase_
-  extern f_return_status fl_int32s_increase(f_int32s_t *int32s) ;
-#endif // _di_fl_int32s_increase_
+#ifndef _di_fl_type_int32s_increase_
+  extern f_return_status fl_type_int32s_increase(f_int32s_t *int32s) ;
+#endif // _di_fl_type_int32s_increase_
 
 /**
  * Increase the size of int32s array by the given amount, but only if necessary.
@@ -434,9 +434,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int32s_increase_by_
-  extern f_return_status fl_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s);
-#endif // _di_fl_int32s_increase_by_
+#ifndef _di_fl_type_int32s_increase_by_
+  extern f_return_status fl_type_int32s_increase_by(const f_array_length_t amount, f_int32s_t *int32s);
+#endif // _di_fl_type_int32s_increase_by_
 
 /**
  * Increase the size of int32s array, but only if necessary.
@@ -449,9 +449,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int32ss_increase_
-  extern f_return_status fl_int32ss_increase(f_int32ss_t *int32ss);
-#endif // _di_fl_int32ss_increase_
+#ifndef _di_fl_type_int32ss_increase_
+  extern f_return_status fl_type_int32ss_increase(f_int32ss_t *int32ss);
+#endif // _di_fl_type_int32ss_increase_
 
 /**
  * Increase the size of int32ss array by the given amount, but only if necessary.
@@ -466,9 +466,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int32ss_increase_by_
-  extern f_return_status fl_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss);
-#endif // _di_fl_int32ss_increase_by_
+#ifndef _di_fl_type_int32ss_increase_by_
+  extern f_return_status fl_type_int32ss_increase_by(const f_array_length_t amount, f_int32ss_t *int32ss);
+#endif // _di_fl_type_int32ss_increase_by_
 
 /**
  * Increase the size of uint32s array, but only if necessary.
@@ -481,9 +481,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint32s_increase_
-  extern f_return_status fl_uint32s_increase(f_uint32s_t *uint32s) ;
-#endif // _di_fl_uint32s_increase_
+#ifndef _di_fl_type_uint32s_increase_
+  extern f_return_status fl_type_uint32s_increase(f_uint32s_t *uint32s) ;
+#endif // _di_fl_type_uint32s_increase_
 
 /**
  * Increase the size of uint32s array by the given amount, but only if necessary.
@@ -498,9 +498,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint32s_increase_by_
-  extern f_return_status fl_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s);
-#endif // _di_fl_uint32s_increase_by_
+#ifndef _di_fl_type_uint32s_increase_by_
+  extern f_return_status fl_type_uint32s_increase_by(const f_array_length_t amount, f_uint32s_t *uint32s);
+#endif // _di_fl_type_uint32s_increase_by_
 
 /**
  * Increase the size of uint32s array, but only if necessary.
@@ -513,9 +513,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint32ss_increase_
-  extern f_return_status fl_uint32ss_increase(f_uint32ss_t *uint32ss);
-#endif // _di_fl_uint32ss_increase_
+#ifndef _di_fl_type_uint32ss_increase_
+  extern f_return_status fl_type_uint32ss_increase(f_uint32ss_t *uint32ss);
+#endif // _di_fl_type_uint32ss_increase_
 
 /**
  * Increase the size of uint32ss array by the given amount, but only if necessary.
@@ -530,9 +530,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint32ss_increase_by_
-  extern f_return_status fl_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
-#endif // _di_fl_uint32ss_increase_by_
+#ifndef _di_fl_type_uint32ss_increase_by_
+  extern f_return_status fl_type_uint32ss_increase_by(const f_array_length_t amount, f_uint32ss_t *uint32ss);
+#endif // _di_fl_type_uint32ss_increase_by_
 
 /**
  * Increase the size of int64s array, but only if necessary.
@@ -673,9 +673,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int128s_increase_
-  extern f_return_status fl_int128s_increase(f_int128s_t *int128s) ;
-#endif // _di_fl_int128s_increase_
+#ifndef _di_fl_type_int128s_increase_
+  extern f_return_status fl_type_int128s_increase(f_int128s_t *int128s) ;
+#endif // _di_fl_type_int128s_increase_
 
 /**
  * Increase the size of int128s array by the given amount, but only if necessary.
@@ -690,9 +690,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int128s_increase_by_
-  extern f_return_status fl_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s);
-#endif // _di_fl_int128s_increase_by_
+#ifndef _di_fl_type_int128s_increase_by_
+  extern f_return_status fl_type_int128s_increase_by(const f_array_length_t amount, f_int128s_t *int128s);
+#endif // _di_fl_type_int128s_increase_by_
 
 /**
  * Increase the size of int128s array, but only if necessary.
@@ -705,9 +705,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int128ss_increase_
-  extern f_return_status fl_int128ss_increase(f_int128ss_t *int128ss);
-#endif // _di_fl_int128ss_increase_
+#ifndef _di_fl_type_int128ss_increase_
+  extern f_return_status fl_type_int128ss_increase(f_int128ss_t *int128ss);
+#endif // _di_fl_type_int128ss_increase_
 
 /**
  * Increase the size of int128ss array by the given amount, but only if necessary.
@@ -722,9 +722,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_int128ss_increase_by_
-  extern f_return_status fl_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss);
-#endif // _di_fl_int128ss_increase_by_
+#ifndef _di_fl_type_int128ss_increase_by_
+  extern f_return_status fl_type_int128ss_increase_by(const f_array_length_t amount, f_int128ss_t *int128ss);
+#endif // _di_fl_type_int128ss_increase_by_
 
 /**
  * Increase the size of uint128s array, but only if necessary.
@@ -737,9 +737,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint128s_increase_
-  extern f_return_status fl_uint128s_increase(f_uint128s_t *uint128s) ;
-#endif // _di_fl_uint128s_increase_
+#ifndef _di_fl_type_uint128s_increase_
+  extern f_return_status fl_type_uint128s_increase(f_uint128s_t *uint128s) ;
+#endif // _di_fl_type_uint128s_increase_
 
 /**
  * Increase the size of uint128s array by the given amount, but only if necessary.
@@ -754,9 +754,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint128s_increase_by_
-  extern f_return_status fl_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s);
-#endif // _di_fl_uint128s_increase_by_
+#ifndef _di_fl_type_uint128s_increase_by_
+  extern f_return_status fl_type_uint128s_increase_by(const f_array_length_t amount, f_uint128s_t *uint128s);
+#endif // _di_fl_type_uint128s_increase_by_
 
 /**
  * Increase the size of uint128s array, but only if necessary.
@@ -769,9 +769,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint128ss_increase_
-  extern f_return_status fl_uint128ss_increase(f_uint128ss_t *uint128ss);
-#endif // _di_fl_uint128ss_increase_
+#ifndef _di_fl_type_uint128ss_increase_
+  extern f_return_status fl_type_uint128ss_increase(f_uint128ss_t *uint128ss);
+#endif // _di_fl_type_uint128ss_increase_
 
 /**
  * Increase the size of uint128ss array by the given amount, but only if necessary.
@@ -786,9 +786,9 @@ extern "C" {
  *   F_memory_reallocation (with error bit) on reallocation error.
  *   F_array_too_large (with error bit) if new length is larger than max array length.
  */
-#ifndef _di_fl_uint128ss_increase_by_
-  extern f_return_status fl_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
-#endif // _di_fl_uint128ss_increase_by_
+#ifndef _di_fl_type_uint128ss_increase_by_
+  extern f_return_status fl_type_uint128ss_increase_by(const f_array_length_t amount, f_uint128ss_t *uint128ss);
+#endif // _di_fl_type_uint128ss_increase_by_
 
 #ifdef __cplusplus
 } // extern "C"
-- 
1.8.3.1