Massive update from unsigned sizes and indices to signed.

16 files changed, 151 insertions, 151 deletions

diff --git a/docs/cbits_api.md b/docs/cbits_api.md
index b21611df..726fb68b 100644
--- a/docs/cbits_api.md
+++ b/docs/cbits_api.md
@@ -21,34 +21,34 @@ All cbits definitions and prototypes are available by including a single header
 ```c
 cbits            cbits_init(void);
 cbits            cbits_from(const char* str);
-cbits            cbits_with_size(size_t size, bool value);               // size must be <= N if N is defined
-cbits            cbits_with_pattern(size_t size, uint64_t pattern); 
+cbits            cbits_with_size(intptr_t size, bool value);               // size must be <= N if N is defined
+cbits            cbits_with_pattern(intptr_t size, uint64_t pattern); 
 cbits            cbits_clone(cbits other);
 
 void             cbits_clear(cbits* self);
 cbits*           cbits_copy(cbits* self, const cbits* other);
-void             cbits_resize(cbits* self, size_t size, bool value);     // only if i_len is not defined
+void             cbits_resize(cbits* self, intptr_t size, bool value);     // only if i_len is not defined
 void             cbits_drop(cbits* self);
 
 cbits*           cbits_take(cbits* self, const cbits* other);            // give other to self
 cbits            cbits_move(cbits* self);                                // transfer self to caller
 
-size_t           cbits_size(const cbits* self);
-size_t           cbits_count(const cbits* self);                         // count number of bits set
+intptr_t         cbits_size(const cbits* self);
+intptr_t         cbits_count(const cbits* self);                         // count number of bits set
 
-bool             cbits_test(const cbits* self, size_t i);
-bool             cbits_at(const cbits* self, size_t i);                  // same as cbits_test()
+bool             cbits_test(const cbits* self, intptr_t i);
+bool             cbits_at(const cbits* self, intptr_t i);                  // same as cbits_test()
 bool             cbits_subset_of(const cbits* self, const cbits* other); // is set a subset of other?
 bool             cbits_disjoint(const cbits* self, const cbits* other);  // no common bits
-char*            cbits_to_str(const cbits* self, char* str, size_t start, size_t stop);
+char*            cbits_to_str(const cbits* self, char* str, intptr_t start, intptr_t stop);
 
-void             cbits_set(cbits* self, size_t i);
-void             cbits_reset(cbits* self, size_t i);
-void             cbits_set_value(cbits* self, size_t i, bool value);
+void             cbits_set(cbits* self, intptr_t i);
+void             cbits_reset(cbits* self, intptr_t i);
+void             cbits_set_value(cbits* self, intptr_t i, bool value);
 void             cbits_set_all(cbits* self, bool value);
 void             cbits_set_pattern(cbits* self, uint64_t pattern);
 void             cbits_flip_all(cbits* self);
-void             cbits_flip(cbits* self, size_t i);
+void             cbits_flip(cbits* self, intptr_t i);
 
 void             cbits_intersect(cbits* self, const cbits* other);
 void             cbits_union(cbits* self, const cbits* other);
@@ -70,19 +70,19 @@ void             cbits_xor(cbits* self, const cbits* other);             // set
 #include <math.h>
 #include <time.h>
 
-cbits sieveOfEratosthenes(size_t n)
+cbits sieveOfEratosthenes(intptr_t n)
 {
     cbits bits = cbits_with_size(n>>1, true);
-    size_t q = (size_t) sqrt(n);
+    intptr_t q = (intptr_t) sqrt(n);
 
-    for (size_t i = 3; i <= q; i += 2) {
-        for (size_t j = i; j < n; j += 2) {
+    for (intptr_t i = 3; i <= q; i += 2) {
+        for (intptr_t j = i; j < n; j += 2) {
             if (cbits_test(&bits, j>>1)) {
                 i = j;
                 break;
             }
         }
-        for (size_t j = i*i; j < n; j += i*2)
+        for (intptr_t j = i*i; j < n; j += i*2)
             cbits_reset(&bits, j>>1);
     }
     return bits;
@@ -90,19 +90,19 @@ cbits sieveOfEratosthenes(size_t n)
 
 int main(void)
 {
-    size_t n = 100000000;
-    printf("computing prime numbers up to %" c_ZU "\n", n);
+    intptr_t n = 100000000;
+    printf("computing prime numbers up to %" c_ZI "\n", n);
 
     clock_t t1 = clock();
     cbits primes = sieveOfEratosthenes(n + 1);
-    size_t nprimes = cbits_count(&primes);
+    intptr_t nprimes = cbits_count(&primes);
     clock_t t2 = clock();
 
-    printf("number of primes: %" c_ZU ", time: %f\n", nprimes, (float)(t2 - t1)/CLOCKS_PER_SEC);
+    printf("number of primes: %" c_ZI ", time: %f\n", nprimes, (float)(t2 - t1)/CLOCKS_PER_SEC);
 
     printf(" 2");
-    for (size_t i = 3; i < 1000; i += 2)
-       if (cbits_test(&primes, i>>1)) printf(" %" c_ZU, i);
+    for (intptr_t i = 3; i < 1000; i += 2)
+       if (cbits_test(&primes, i>>1)) printf(" %" c_ZI, i);
     puts("");
 
     cbits_drop(&primes);
diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 18edbeba..43f747ab 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -361,5 +361,5 @@ Memory allocator for the entire library. Macros can be overridden by the user.
 - **c_ARRAYLEN(array)**: Return number of elements in an array. array must not be a pointer!
 ```c
 int array[] = {1, 2, 3, 4};
-size_t n = c_ARRAYLEN(array);
+intptr_t n = c_ARRAYLEN(array);
 ```
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index 584d382f..44a75fc2 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -27,21 +27,21 @@ See the c++ class [std::deque](https://en.cppreference.com/w/cpp/container/deque
 
 ```c
 cdeq_X              cdeq_X_init(void);
-cdeq_X              cdeq_X_with_capacity(size_t size);
+cdeq_X              cdeq_X_with_capacity(intptr_t size);
 cdeq_X              cdeq_X_clone(cdeq_X deq);
 
 void                cdeq_X_clear(cdeq_X* self);
 void                cdeq_X_copy(cdeq_X* self, const cdeq_X* other);
 cdeq_X_iter         cdeq_X_copy_range(cdeq_X* self, i_val* pos, const i_val* p1, const i_val* p2);
-bool                cdeq_X_reserve(cdeq_X* self, size_t cap);
+bool                cdeq_X_reserve(cdeq_X* self, intptr_t cap);
 void                cdeq_X_shrink_to_fit(cdeq_X* self);
 void                cdeq_X_drop(cdeq_X* self);                                                    // destructor
 
 bool                cdeq_X_empty(const cdeq_X* self);
-size_t              cdeq_X_size(const cdeq_X* self);
-size_t              cdeq_X_capacity(const cdeq_X* self);
+intptr_t            cdeq_X_size(const cdeq_X* self);
+intptr_t            cdeq_X_capacity(const cdeq_X* self);
 
-const cdeq_X_value* cdeq_X_at(const cdeq_X* self, size_t idx);
+const cdeq_X_value* cdeq_X_at(const cdeq_X* self, intptr_t idx);
 const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_valraw raw);                                 // return NULL if not found
 cdeq_X_value*       cdeq_X_get_mut(cdeq_X* self, i_valraw raw);                                   // mutable get
 cdeq_X_iter         cdeq_X_find(const cdeq_X* self, i_valraw raw);
@@ -60,18 +60,18 @@ cdeq_X_value*       cdeq_X_emplace_back(cdeq_X* self, i_valraw raw);
 cdeq_X_value*       cdeq_X_emplace(cdeq_X* self, i_valraw raw);                                  // alias for emplace_back()
 void                cdeq_X_pop_back(cdeq_X* self);
 
-cdeq_X_iter         cdeq_X_insert(cdeq_X* self, size_t idx, i_val value);                        // move value 
-cdeq_X_iter         cdeq_X_insert_n(cdeq_X* self, size_t idx, const i_val[] arr, size_t n);      // move arr values
+cdeq_X_iter         cdeq_X_insert(cdeq_X* self, intptr_t idx, i_val value);                      // move value 
+cdeq_X_iter         cdeq_X_insert_n(cdeq_X* self, intptr_t idx, const i_val[] arr, intptr_t n);  // move arr values
 cdeq_X_iter         cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value);                 // move value 
 cdeq_X_iter         cdeq_X_insert_range(cdeq_X* self, i_val* pos,
                                         const i_val* p1, const i_val* p2);
 
-cdeq_X_iter         cdeq_X_emplace_n(cdeq_X* self, size_t idx, const i_valraw[] arr, size_t n);  // clone values
+cdeq_X_iter         cdeq_X_emplace_n(cdeq_X* self, intptr_t idx, const i_valraw[] arr, intptr_t n);  // clone values
 cdeq_X_iter         cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter it, i_valraw raw);
 cdeq_X_iter         cdeq_X_emplace_range(cdeq_X* self, i_val* pos,
                                          const i_valraw* p1, const i_valraw* p2);
 
-cdeq_X_iter         cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n);
+cdeq_X_iter         cdeq_X_erase_n(cdeq_X* self, intptr_t idx, intptr_t n);
 cdeq_X_iter         cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter it);
 cdeq_X_iter         cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter it1, cdeq_X_iter it2);
 cdeq_X_iter         cdeq_X_erase_range_p(cdeq_X* self, i_val* p1, i_val* p2);
@@ -83,7 +83,7 @@ void                cdeq_X_sort_range(cdeq_X_iter i1, cdeq_X_iter i2,
 cdeq_X_iter         cdeq_X_begin(const cdeq_X* self);
 cdeq_X_iter         cdeq_X_end(const cdeq_X* self);
 void                cdeq_X_next(cdeq_X_iter* it);
-cdeq_X_iter         cdeq_X_advance(cdeq_X_iter it, intptr_t n);
+cdeq_X_iter         cdeq_X_advance(cdeq_X_iter it, size_t n);
 
 cdeq_X_raw          cdeq_X_value_toraw(cdeq_X_value* pval);
 cdeq_X_value        cdeq_X_value_clone(cdeq_X_value val);
diff --git a/docs/clist_api.md b/docs/clist_api.md
index e97d7b5d..13c27308 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -48,7 +48,7 @@ void                clist_X_copy(clist_X* self, const clist_X* other);
 void                clist_X_drop(clist_X* self);                                          // destructor
 
 bool                clist_X_empty(const clist_X* list);
-size_t              clist_X_count(const clist_X* list);                                   // size() in O(n) time
+intptr_t            clist_X_count(const clist_X* list);                                   // size() in O(n) time
 
 clist_X_value*      clist_X_back(const clist_X* self);
 clist_X_value*      clist_X_front(const clist_X* self);
@@ -67,7 +67,7 @@ clist_X_iter        clist_X_emplace_at(clist_X* self, clist_X_iter it, i_valraw
 void                clist_X_pop_front(clist_X* self);
 clist_X_iter        clist_X_erase_at(clist_X* self, clist_X_iter it);                     // return iter after it
 clist_X_iter        clist_X_erase_range(clist_X* self, clist_X_iter it1, clist_X_iter it2);
-size_t              clist_X_remove(clist_X* self, i_valraw raw);                          // removes all matches
+intptr_t            clist_X_remove(clist_X* self, i_valraw raw);                          // removes all matches
 
 clist_X             clist_X_split_off(clist_X* self, clist_X_iter i1, clist_X_iter i2);   // split off [i1, i2)
 clist_X_iter        clist_X_splice(clist_X* self, clist_X_iter it, clist_X* other);       // return updated valid it
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 3848e67e..7b8fbb8f 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -48,20 +48,20 @@ See the c++ class [std::unordered_map](https://en.cppreference.com/w/cpp/contain
 
 ```c
 cmap_X                cmap_X_init(void);
-cmap_X                cmap_X_with_capacity(size_t cap);
+cmap_X                cmap_X_with_capacity(intptr_t cap);
 cmap_X                cmap_X_clone(cmap_x map);
 
 void                  cmap_X_clear(cmap_X* self);
 void                  cmap_X_copy(cmap_X* self, const cmap_X* other);
-float                 cmap_X_max_load_factor(const cmap_X* self);                                     // default: 0.85f
-bool                  cmap_X_reserve(cmap_X* self, size_t size);
+float                 cmap_X_max_load_factor(const cmap_X* self);                               // default: 0.85f
+bool                  cmap_X_reserve(cmap_X* self, intptr_t size);
 void                  cmap_X_shrink_to_fit(cmap_X* self);
 void                  cmap_X_drop(cmap_X* self);                                                // destructor
 
-size_t                cmap_X_size(const cmap_X* self);
-size_t                cmap_X_capacity(const cmap_X* self);                                      // buckets * max_load_factor
+intptr_t              cmap_X_size(const cmap_X* self);
+intptr_t              cmap_X_capacity(const cmap_X* self);                                      // buckets * max_load_factor
 bool                  cmap_X_empty(const cmap_X* self );
-size_t                cmap_X_bucket_count(const cmap_X* self);                                  // num. of allocated buckets
+intptr_t              cmap_X_bucket_count(const cmap_X* self);                                  // num. of allocated buckets
 
 const cmap_X_mapped*  cmap_X_at(const cmap_X* self, i_keyraw rkey);                             // rkey must be in map
 cmap_X_mapped*        cmap_X_at_mut(cmap_X* self, i_keyraw rkey);                               // mutable at
@@ -77,7 +77,7 @@ cmap_X_result         cmap_X_push(cmap_X* self, cmap_X_value entry);
 cmap_X_result         cmap_X_emplace(cmap_X* self, i_keyraw rkey, i_valraw rmapped);            // no change if rkey in map
 cmap_X_result         cmap_X_emplace_or_assign(cmap_X* self, i_keyraw rkey, i_valraw rmapped);  // always update rmapped
 
-size_t                cmap_X_erase(cmap_X* self, i_keyraw rkey);                                // return 0 or 1
+intptr_t              cmap_X_erase(cmap_X* self, i_keyraw rkey);                                // return 0 or 1
 cmap_X_iter           cmap_X_erase_at(cmap_X* self, cmap_X_iter it);                            // return iter after it
 void                  cmap_X_erase_entry(cmap_X* self, cmap_X_value* entry);
 
@@ -93,7 +93,7 @@ Helpers:
 ```c
 uint64_t              c_default_hash(const X *obj);                            // macro, calls cfasthash(obj, sizeof *obj)
 uint64_t              cstrhash(const char *str);                               // string hash funcion, uses strlen()
-uint64_t              cfasthash(const void *data, size_t len);                 // base hash function
+uint64_t              cfasthash(const void *data, intptr_t len);               // base hash function
 
 // equalto template parameter functions:
 bool                  c_default_eq(const i_keyraw* a, const i_keyraw* b);      // *a == *b
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index 392d3149..48a5b29e 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -28,17 +28,17 @@ See the c++ class [std::priority_queue](https://en.cppreference.com/w/cpp/contai
 
 ```c
 cpque_X             cpque_X_init(void);                    // create empty pri-queue.
-cpque_X             cpque_X_with_capacity(size_t cap);
-cpque_X             cpque_X_with_size(size_t size, i_val null);
+cpque_X             cpque_X_with_capacity(intptr_t cap);
+cpque_X             cpque_X_with_size(intptr_t size, i_val null);
 cpque_X             cpque_X_clone(cpque_X pq);
 
 void                cpque_X_clear(cpque_X* self);
-bool                cpque_X_reserve(cpque_X* self, size_t n);
+bool                cpque_X_reserve(cpque_X* self, intptr_t n);
 void                cpque_X_shrink_to_fit(cpque_X* self);
 void                cpque_X_copy(cpque_X* self, const cpque_X* other);
 void                cpque_X_drop(cpque_X* self);        // destructor
 
-size_t              cpque_X_size(const cpque_X* self);
+intptr_t            cpque_X_size(const cpque_X* self);
 bool                cpque_X_empty(const cpque_X* self);
 i_val*              cpque_X_top(const cpque_X* self);
 
@@ -47,7 +47,7 @@ void                cpque_X_push(cpque_X* self, i_val value);
 void                cpque_X_emplace(cpque_X* self, i_valraw raw); // converts from raw
 
 void                cpque_X_pop(cpque_X* self);
-void                cpque_X_erase_at(cpque_X* self, size_t idx);
+void                cpque_X_erase_at(cpque_X* self, intptr_t idx);
 
 i_val               cpque_X_value_clone(i_val value);
 ```
@@ -71,7 +71,7 @@ i_val               cpque_X_value_clone(i_val value);
 
 int main()
 {
-    size_t N = 10000000;
+    intptr_t N = 10000000;
     stc64_t rng = stc64_new(1234);
     stc64_uniform_t dist = stc64_uniform_new(0, N * 10);
 
diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md
index 977fa855..212cdabe 100644
--- a/docs/cqueue_api.md
+++ b/docs/cqueue_api.md
@@ -32,7 +32,7 @@ void                cqueue_X_clear(cqueue_X* self);
 void                cqueue_X_copy(cqueue_X* self, const cqueue_X* other);
 void                cqueue_X_drop(cqueue_X* self);       // destructor
 
-size_t              cqueue_X_size(const cqueue_X* self);
+intptr_t            cqueue_X_size(const cqueue_X* self);
 bool                cqueue_X_empty(const cqueue_X* self);
 cqueue_X_value*     cqueue_X_front(const cqueue_X* self);
 cqueue_X_value*     cqueue_X_back(const cqueue_X* self);
diff --git a/docs/crandom_api.md b/docs/crandom_api.md
index bd3bf848..7dced0eb 100644
--- a/docs/crandom_api.md
+++ b/docs/crandom_api.md
@@ -76,7 +76,7 @@ double              stc64_normalf(stc64_t* rng, stc64_normalf_t* dist);
 
 // Declare int -> int sorted map. Uses typetag 'i' for ints.
 #define i_key int
-#define i_val size_t
+#define i_val intptr_t
 #define i_tag i
 #include <stc/csmap.h>
 
@@ -102,7 +102,7 @@ int main()
     // Print the gaussian bar chart
     cstr bar = cstr_init();
     c_FOREACH (i, csmap_i, mhist) {
-        size_t n = (size_t) (i.ref->second * StdDev * Scale * 2.5 / N);
+        int n = (int)(i.ref->second * StdDev * Scale * 2.5 / N);
         if (n > 0) {
             cstr_resize(&bar, n, '*');
             printf("%4d %s\n", i.ref->first, cstr_str(&bar));
diff --git a/docs/cset_api.md b/docs/cset_api.md
index e1d08a87..2e80a49b 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -30,20 +30,20 @@ A **cset** is an associative container that contains a set of unique objects of
 
 ```c
 cset_X              cset_X_init(void);
-cset_X              cset_X_with_capacity(size_t cap);
+cset_X              cset_X_with_capacity(intptr_t cap);
 cset_X              cset_X_clone(cset_x set);
 
 void                cset_X_clear(cset_X* self);
 void                cset_X_copy(cset_X* self, const cset_X* other);
 float               cset_X_max_load_factor(const cset_X* self);                      // default: 0.85
-bool                cset_X_reserve(cset_X* self, size_t size);
+bool                cset_X_reserve(cset_X* self, intptr_t size);
 void                cset_X_shrink_to_fit(cset_X* self);
 void                cset_X_drop(cset_X* self);                                       // destructor
 
-size_t              cset_X_size(const cset_X* self);                                 // num. of allocated buckets
-size_t              cset_X_capacity(const cset_X* self);                             // buckets * max_load_factor
+intptr_t            cset_X_size(const cset_X* self);                                 // num. of allocated buckets
+intptr_t            cset_X_capacity(const cset_X* self);                             // buckets * max_load_factor
 bool                cset_X_empty(const cset_X* self);
-size_t              cset_X_bucket_count(const cset_X* self);
+intptr_t            cset_X_bucket_count(const cset_X* self);
 
 bool                cset_X_contains(const cset_X* self, i_keyraw rkey);
 const cset_X_value* cset_X_get(const cset_X* self, i_keyraw rkey);                   // return NULL if not found
@@ -54,7 +54,7 @@ cset_X_result       cset_X_insert(cset_X* self, i_key key);
 cset_X_result       cset_X_push(cset_X* self, i_key key);                            // alias for insert.
 cset_X_result       cset_X_emplace(cset_X* self, i_keyraw rkey);
 
-size_t              cset_X_erase(cset_X* self, i_keyraw rkey);                       // return 0 or 1
+intptr_t            cset_X_erase(cset_X* self, i_keyraw rkey);                       // return 0 or 1
 cset_X_iter         cset_X_erase_at(cset_X* self, cset_X_iter it);                   // return iter after it
 void                cset_X_erase_entry(cset_X* self, cset_X_value* entry);
 
diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 687a6cab..d0a57bdb 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -42,8 +42,8 @@ See the c++ class [std::map](https://en.cppreference.com/w/cpp/container/map) fo
 
 ```c
 csmap_X               csmap_X_init(void);
-csset_X               csmap_X_with_capacity(size_t cap);
-bool                  csmap_X_reserve(csmap_X* self, size_t cap);
+csset_X               csmap_X_with_capacity(intptr_t cap);
+bool                  csmap_X_reserve(csmap_X* self, intptr_t cap);
 void                  csmap_X_shrink_to_fit(csmap_X* self);
 csmap_X               csmap_X_clone(csmap_x map);
 
@@ -51,7 +51,7 @@ void                  csmap_X_clear(csmap_X* self);
 void                  csmap_X_copy(csmap_X* self, const csmap_X* other);
 void                  csmap_X_drop(csmap_X* self);                                               // destructor
 
-size_t                csmap_X_size(const csmap_X* self);
+intptr_t              csmap_X_size(const csmap_X* self);
 bool                  csmap_X_empty(const csmap_X* self);
 bool                  csmap_X_capacity(const csmap_X* self);
 
@@ -74,7 +74,7 @@ csmap_X_result        csmap_X_push(csmap_X* self, csmap_X_value entry);
 csmap_X_result        csmap_X_emplace(csmap_X* self, i_keyraw rkey, i_valraw rmapped);           // no change if rkey in map
 csmap_X_result        csmap_X_emplace_or_assign(csmap_X* self, i_keyraw rkey, i_valraw rmapped); // always update rmapped
 
-size_t                csmap_X_erase(csmap_X* self, i_keyraw rkey);
+intptr_t              csmap_X_erase(csmap_X* self, i_keyraw rkey);
 csmap_X_iter          csmap_X_erase_at(csmap_X* self, csmap_X_iter it);                          // returns iter after it
 csmap_X_iter          csmap_X_erase_range(csmap_X* self, csmap_X_iter it1, csmap_X_iter it2);    // returns updated it2
 
diff --git a/docs/cspan_api.md b/docs/cspan_api.md
index c4cb7c16..8f6f695f 100644
--- a/docs/cspan_api.md
+++ b/docs/cspan_api.md
@@ -20,32 +20,32 @@ using_cspan4(S, ValueType);             // define span types S, S2, S3, S4 with
 Note that `cspan_md()`, `cmake_from*()`, `cspan_atN()`, `and cspan_subspanN()` require a (safe) cast to its span-type
 on assignment, but not on initialization of a span variable. All functions are type-safe, and arguments are side-effect safe, except for SpanType arg. which must not have side-effects.
 ```c
-SpanTypeN       cspan_md(ValueType* data,  size_t xdim, ...);           // create a multi-dimensional cspan
+SpanTypeN       cspan_md(ValueType* data,  intptr_t xdim, ...);           // create a multi-dimensional cspan
 SpanType        cspan_make(T SpanType, {v1, v2, ...});                  // make a 1d-dimensional cspan from values
 SpanType        cspan_from(STCContainer* cnt);                          // create a 1d cspan from a compatible STC container
 SpanType        cspan_from_array(ValueType array[]);                    // create a 1d cspan from a C array
 
-size_t          cspan_size(const SpanTypeN* self);                      // return number of elements
+intptr_t        cspan_size(const SpanTypeN* self);                      // return number of elements
 unsigned        cspan_rank(const SpanTypeN* self);                      // return number of dimensions
-size_t          cspan_index(const SpanTypeN* self, size_t x, ...);      // index of element
+intptr_t        cspan_index(const SpanTypeN* self, intptr_t x, ...);      // index of element
                 
-ValueType*      cspan_at(SpanTypeN* self, size_t x, ...);               // at(): num of args specifies rank of input span.
+ValueType*      cspan_at(SpanTypeN* self, intptr_t x, ...);               // at(): num of args specifies rank of input span.
 ValueType*      cspan_front(SpanTypeN* self);
 ValueType*      cspan_back(SpanTypeN* self);
 
                 // return a subspan of lower rank:
-SpanType        cspan_submd2(SpanType2* self, size_t x);                // return a 1d subspan from a 2d span.
-SpanTypeN       cspan_submd3(SpanType3* self, size_t x, ...);           // return a 1d or 2d subspan from a 3d span.
-SpanTypeN       cspan_submd4(SpanType4* self, size_t x, ...);           // number of args determines rank of output span.
+SpanType        cspan_submd2(SpanType2* self, intptr_t x);                // return a 1d subspan from a 2d span.
+SpanTypeN       cspan_submd3(SpanType3* self, intptr_t x, ...);           // return a 1d or 2d subspan from a 3d span.
+SpanTypeN       cspan_submd4(SpanType4* self, intptr_t x, ...);           // number of args determines rank of output span.
 
                 // return a sliced span of same rank:
 void            cspan_slice(SpanTypeN* self, {x0,x1}, {y0,y1},...);     // slice multidim span into a md subspan.
 
                 // return a subspan of same rank. Like e.g. cspan_slice(&ms3, {offset, offset+count}, {0}, {0});
-SpanType        cspan_subspan(const SpanType* self, size_t offset, size_t count);
-SpanType2       cspan_subspan2(const SpanType2 self, size_t offset, size_t count);
-SpanType3       cspan_subspan3(const SpanType3 self, size_t offset, size_t count);
-SpanType4       cspan_subspan4(const SpanType4 self, size_t offset, size_t count);
+SpanType        cspan_subspan(const SpanType* self, intptr_t offset, intptr_t count);
+SpanType2       cspan_subspan2(const SpanType2 self, intptr_t offset, intptr_t count);
+SpanType3       cspan_subspan3(const SpanType3 self, intptr_t offset, intptr_t count);
+SpanType4       cspan_subspan4(const SpanType4 self, intptr_t offset, intptr_t count);
 
 SpanTypeN_iter  SpanType_begin(const SpanTypeN* self);
 SpanTypeN_iter  SpanType_end(const SpanTypeN* self);
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 6276f486..7e068909 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -28,8 +28,8 @@ See the c++ class [std::set](https://en.cppreference.com/w/cpp/container/set) fo
 
 ```c
 csset_X              csset_X_init(void);
-csset_X              csset_X_with_capacity(size_t cap);
-bool                 csset_X_reserve(csset_X* self, size_t cap);
+csset_X              csset_X_with_capacity(intptr_t cap);
+bool                 csset_X_reserve(csset_X* self, intptr_t cap);
 void                 csset_X_shrink_to_fit(csset_X* self);
 csset_X              csset_X_clone(csset_x set);
 
@@ -37,7 +37,7 @@ void                 csset_X_clear(csset_X* self);
 void                 csset_X_copy(csset_X* self, const csset_X* other);
 void                 csset_X_drop(csset_X* self);                                             // destructor
 
-size_t               csset_X_size(const csset_X* self);
+intptr_t             csset_X_size(const csset_X* self);
 bool                 csset_X_empty(const csset_X* self);
 
 const csset_X_value* csset_X_get(const csset_X* self, i_keyraw rkey);                         // const get
@@ -51,7 +51,7 @@ csset_X_result       csset_X_insert(csset_X* self, i_key key);
 csset_X_result       csset_X_push(csset_X* self, i_key key);                                  // alias for insert()
 csset_X_result       csset_X_emplace(csset_X* self, i_keyraw rkey);
 
-size_t               csset_X_erase(csset_X* self, i_keyraw rkey);
+intptr_t             csset_X_erase(csset_X* self, i_keyraw rkey);
 csset_X_iter         csset_X_erase_at(csset_X* self, csset_X_iter it);                        // return iter after it
 csset_X_iter         csset_X_erase_range(csset_X* self, csset_X_iter it1, csset_X_iter it2);  // return updated it2
 
diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index e8423385..b1371f4e 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -26,24 +26,24 @@ See the c++ class [std::stack](https://en.cppreference.com/w/cpp/container/stack
 
 ```c
 cstack_X            cstack_X_init(void);
-cstack_X            cstack_X_with_capacity(size_t cap);
-cstack_X            cstack_X_with_size(size_t size, i_val fill);
+cstack_X            cstack_X_with_capacity(intptr_t cap);
+cstack_X            cstack_X_with_size(intptr_t size, i_val fill);
 cstack_X            cstack_X_clone(cstack_X st);
 
 void                cstack_X_clear(cstack_X* self);
-bool                cstack_X_reserve(cstack_X* self, size_t n);
+bool                cstack_X_reserve(cstack_X* self, intptr_t n);
 void                cstack_X_shrink_to_fit(cstack_X* self);
-i_val*              cstack_X_append_uninit(cstack_X* self, size_t n);
+i_val*              cstack_X_append_uninit(cstack_X* self, intptr_t n);
 void                cstack_X_copy(cstack_X* self, const cstack_X* other);
 void                cstack_X_drop(cstack_X* self);                       // destructor
 
-size_t              cstack_X_size(const cstack_X* self);
-size_t              cstack_X_capacity(const cstack_X* self);
+intptr_t            cstack_X_size(const cstack_X* self);
+intptr_t            cstack_X_capacity(const cstack_X* self);
 bool                cstack_X_empty(const cstack_X* self);
 
 i_val*              cstack_X_top(const cstack_X* self);
-const i_val*        cstack_X_at(const cstack_X* self, size_t idx);
-i_val*              cstack_X_at_mut(cstack_X* self, size_t idx);
+const i_val*        cstack_X_at(const cstack_X* self, intptr_t idx);
+i_val*              cstack_X_at_mut(cstack_X* self, intptr_t idx);
 
 i_val*              cstack_X_push(cstack_X* self, i_val value);
 i_val*              cstack_X_emplace(cstack_X* self, i_valraw raw);
diff --git a/docs/cstr_api.md b/docs/cstr_api.md
index 48999654..6bf5c723 100644
--- a/docs/cstr_api.md
+++ b/docs/cstr_api.md
@@ -21,10 +21,10 @@ All cstr definitions and prototypes are available by including a single header f
 cstr         cstr_init(void);                                         // constructor; same as cstr_NULL.
 cstr         cstr_lit(const char literal_only[]);                     // cstr from literal; no strlen() call.
 cstr         cstr_from(const char* str);                              // constructor using strlen()
-cstr         cstr_from_n(const char* str, size_t n);                  // constructor with n first bytes of str
+cstr         cstr_from_n(const char* str, intptr_t n);                  // constructor with n first bytes of str
 cstr         cstr_from_sv(csview sv);                                 // construct cstr from csview
-cstr         cstr_with_capacity(size_t cap);
-cstr         cstr_with_size(size_t len, char fill);                   // repeat fill len times
+cstr         cstr_with_capacity(intptr_t cap);
+cstr         cstr_with_size(intptr_t len, char fill);                   // repeat fill len times
 cstr         cstr_from_fmt(const char* fmt, ...);                     // printf() formatting
 cstr         cstr_clone(cstr s);
 
@@ -37,49 +37,49 @@ char*        cstr_data(cstr* self);                                   // cast to
 csview       cstr_sv(const cstr* self);                               // cast to string view
 cstr_buf     cstr_buffer(cstr* self);                                 // cast to mutable buffer (with capacity)
 
-size_t       cstr_size(const cstr* self);
-size_t       cstr_capacity(const cstr* self);
+intptr_t     cstr_size(const cstr* self);
+intptr_t     cstr_capacity(const cstr* self);
 bool         cstr_empty(const cstr* self);
 
-char*        cstr_reserve(cstr* self, size_t capacity);               // return pointer to buffer
-void         cstr_resize(cstr* self, size_t len, char fill);
+char*        cstr_reserve(cstr* self, intptr_t capacity);               // return pointer to buffer
+void         cstr_resize(cstr* self, intptr_t len, char fill);
 void         cstr_shrink_to_fit(cstr* self);
 void         cstr_clear(cstr* self);
 
 char*        cstr_assign(cstr* self, const char* str);
-char*        cstr_assign_n(cstr* self, const char* str, size_t n);    // assign n first bytes of str
+char*        cstr_assign_n(cstr* self, const char* str, intptr_t n);    // assign n first bytes of str
 char*        cstr_assign_sv(cstr* self, csview sv);
 char*        cstr_copy(cstr* self, cstr s);                           // copy-assign a cstr
 int          cstr_printf(cstr* self, const char* fmt, ...);           // source and target must not overlap.
 
 char*        cstr_append(cstr* self, const char* str);
-char*        cstr_append_n(cstr* self, const char* str, size_t n);    // append n first bytes of str
+char*        cstr_append_n(cstr* self, const char* str, intptr_t n);    // append n first bytes of str
 char*        cstr_append_sv(cstr* self, csview str);
 char*        cstr_append_s(cstr* self, cstr str);
 int          cstr_append_fmt(cstr* self, const char* fmt, ...);       // printf() formatting
-char*        cstr_append_uninit(cstr* self, size_t len);              // return ptr to start of uninited data
+char*        cstr_append_uninit(cstr* self, intptr_t len);              // return ptr to start of uninited data
 
 void         cstr_push(cstr* self, const char* chr);                  // append one utf8 char
 void         cstr_pop(cstr* self);                                    // pop one utf8 char
 
-void         cstr_insert(cstr* self, size_t pos, const char* ins);
-void         cstr_insert_sv(cstr* self, size_t pos, csview ins);
-void         cstr_insert_s(cstr* self, size_t pos, cstr ins);
+void         cstr_insert(cstr* self, intptr_t pos, const char* ins);
+void         cstr_insert_sv(cstr* self, intptr_t pos, csview ins);
+void         cstr_insert_s(cstr* self, intptr_t pos, cstr ins);
 
-void         cstr_erase(cstr* self, size_t pos, size_t len);         // erase len bytes from pos
+void         cstr_erase(cstr* self, intptr_t pos, intptr_t len);         // erase len bytes from pos
 
 void         cstr_replace(cstr* self, const char* search, const char* repl, unsigned count = MAX_INT);
 cstr         cstr_replace_sv(csview in, csview search, csview repl, unsigned count);
-void         cstr_replace_at(cstr* self, size_t pos, size_t len, const char* repl);          // replace at a position
-void         cstr_replace_at_sv(cstr* self, size_t pos, size_t len, const csview repl);
-void         cstr_replace_at_s(cstr* self, size_t pos, size_t len, cstr repl);
+void         cstr_replace_at(cstr* self, intptr_t pos, intptr_t len, const char* repl);          // replace at a position
+void         cstr_replace_at_sv(cstr* self, intptr_t pos, intptr_t len, const csview repl);
+void         cstr_replace_at_s(cstr* self, intptr_t pos, intptr_t len, cstr repl);
 
 bool         cstr_equals(const cstr* self, const char* str);
 bool         cstr_equals_sv(const cstr* self, csview sv);
 bool         cstr_equals_s(const cstr* self, cstr s);
 
-size_t       cstr_find(const cstr* self, const char* search);
-size_t       cstr_find_at(const cstr* self, size_t pos, const char* search);                 // search from pos
+intptr_t     cstr_find(const cstr* self, const char* search);
+intptr_t     cstr_find_at(const cstr* self, intptr_t pos, const char* search);                 // search from pos
 bool         cstr_contains(const cstr* self, const char* search);
 
 bool         cstr_starts_with(const cstr* self, const char* str);
@@ -96,13 +96,13 @@ bool         cstr_getdelim(cstr *self, int delim, FILE *stream);      // does no
 
 #### UTF8 methods
 ```c
-size_t       cstr_u8_size(const cstr* self);                          // number of utf8 codepoints
-size_t       cstr_u8_size_n(const cstr self, size_t nbytes);          // utf8 size within n bytes  
-size_t       cstr_u8_to_pos(const cstr* self, size_t u8idx);          // byte pos offset at utf8 codepoint index
-const char*  cstr_u8_at(const cstr* self, size_t u8idx);              // char* position at utf8 codepoint index
-csview       cstr_u8_chr(const cstr* self, size_t u8idx);             // get utf8 character as a csview
-void         cstr_u8_replace_at(cstr* self, size_t bytepos, size_t u8len, csview repl); // replace u8len utf8 chars
-void         cstr_u8_erase(cstr* self, size_t bytepos, size_t u8len); // erase u8len codepoints from pos
+intptr_t     cstr_u8_size(const cstr* self);                          // number of utf8 codepoints
+intptr_t     cstr_u8_size_n(const cstr self, intptr_t nbytes);        // utf8 size within n bytes  
+intptr_t     cstr_u8_to_pos(const cstr* self, intptr_t u8idx);        // byte pos offset at utf8 codepoint index
+const char*  cstr_u8_at(const cstr* self, intptr_t u8idx);            // char* position at utf8 codepoint index
+csview       cstr_u8_chr(const cstr* self, intptr_t u8idx);           // get utf8 character as a csview
+void         cstr_u8_replace_at(cstr* self, intptr_t bytepos, intptr_t u8len, csview repl); // replace u8len utf8 chars
+void         cstr_u8_erase(cstr* self, intptr_t bytepos, intptr_t u8len); // erase u8len codepoints from pos
 
 // iterate utf8 codepoints
 cstr_iter    cstr_begin(const cstr* self);
@@ -128,7 +128,7 @@ bool         cstr_istarts_with(const cstr* self, const char* str);
 bool         cstr_iends_with(const cstr* self, const char* str);                //   "
 ```
 
-Note that all methods with arguments `(..., const char* str, size_t n)`, `n` must be within the range of `str` length.
+Note that all methods with arguments `(..., const char* str, intptr_t n)`, `n` must be within the range of `str` length.
 
 #### Helper methods:
 ```c
@@ -136,7 +136,7 @@ int          cstr_cmp(const cstr* s1, const cstr* s2);
 bool         cstr_eq(const cstr* s1, const cstr* s2);
 bool         cstr_hash(const cstr* self);
 
-char*        cstrnstrn(const char* str, const char* search, size_t slen, size_t nlen);
+char*        cstrnstrn(const char* str, const char* search, intptr_t slen, intptr_t nlen);
 ```
 
 ## Types
@@ -145,8 +145,8 @@ char*        cstrnstrn(const char* str, const char* search, size_t slen, size_t
 |:----------------|:-------------------------------------------|:---------------------|
 | `cstr`          | `struct { ... }`                           | The string type      |
 | `cstr_value`    | `char`                                     | String element type  |
-| `csview`        | `struct { const char *str; size_t size; }` | String view type     |
-| `cstr_buf`      | `struct { char *data; size_t size, cap; }` | String buffer type   |
+| `csview`        | `struct { const char *str; intptr_t size; }` | String view type     |
+| `cstr_buf`      | `struct { char *data; intptr_t size, cap; }` | String buffer type   |
 
 ## Constants and macros
 
@@ -162,7 +162,7 @@ char*        cstrnstrn(const char* str, const char* search, size_t slen, size_t
 int main() {
     c_AUTO (cstr, s0, s1, full_path) {
         s0 = cstr_lit("Initialization without using strlen().");
-        printf("%s\nLength: %" c_ZU "\n\n", cstr_str(&s0), cstr_size(&s0));
+        printf("%s\nLength: %" c_ZI "\n\n", cstr_str(&s0), cstr_size(&s0));
 
         s1 = cstr_lit("one-nine-three-seven-five.");
         printf("%s\n", cstr_str(&s1));
diff --git a/docs/csview_api.md b/docs/csview_api.md
index 4085a708..8064e4fd 100644
--- a/docs/csview_api.md
+++ b/docs/csview_api.md
@@ -27,31 +27,31 @@ All csview definitions and prototypes are available by including a single header
 
 ```c
 csview          c_SV(const char literal_only[]);                         // construct from literal, no strlen()
-csview          c_SV(const char* str, size_t n);                         // construct from str and length n
+csview          c_SV(const char* str, intptr_t n);                       // construct from str and length n
 csview          csview_lit(const char literal_only[]);                   // alias for c_SV(lit)
 csview          csview_from(const char* str);                            // construct from const char*
-csview          csview_from_n(const char* str, size_t n);                // alias for c_SV(str, n)
+csview          csview_from_n(const char* str, intptr_t n);              // alias for c_SV(str, n)
 
-size_t          csview_size(csview sv);
+intptr_t        csview_size(csview sv);
 bool            csview_empty(csview sv);
 void            csview_clear(csview* self);
 
 bool            csview_equals(csview sv, csview sv2);
-size_t          csview_find(csview sv, const char* str);
-size_t          csview_find_sv(csview sv, csview find);
+intptr_t        csview_find(csview sv, const char* str);
+intptr_t        csview_find_sv(csview sv, csview find);
 bool            csview_contains(csview sv, const char* str);
 bool            csview_starts_with(csview sv, const char* str);
 bool            csview_ends_with(csview sv, const char* str);
 
-csview          csview_substr_ex(csview sv, intptr_t pos, size_t n);     // negative pos count from end
+csview          csview_substr_ex(csview sv, intptr_t pos, intptr_t n);   // negative pos count from end
 csview          csview_slice_ex(csview sv, intptr_t p1, intptr_t p2);    // negative p1, p2 count from end
-csview          csview_token(csview sv, const char* sep, size_t* start); // *start > sv.size after last token
+csview          csview_token(csview sv, const char* sep, intptr_t* start); // *start > sv.size after last token
 ```
 
 #### UTF8 methods
 ```c
-size_t          csview_u8_size(csview sv);
-csview          csview_u8_substr(csview sv, size_t bytepos, size_t u8len);
+intptr_t        csview_u8_size(csview sv);
+csview          csview_u8_substr(csview sv, intptr_t bytepos, intptr_t u8len);
 bool            csview_valid_utf8(csview sv);                            // requires linking with src/utf8code.c
 
 csview_iter     csview_begin(const csview* self);
@@ -60,14 +60,14 @@ void            csview_next(csview_iter* it);                            // utf8
 csview_iter     csview_advance(csview_iter it, intptr_t n);
 
 // from utf8.h
-size_t          utf8_size(const char *s);
-size_t          utf8_size_n(const char *s, size_t nbytes);               // number of UTF8 codepoints within n bytes
-const char*     utf8_at(const char *s, size_t index);                    // from UTF8 index to char* position
-size_t          utf8_pos(const char* s, size_t index);                   // from UTF8 index to byte index position
+intptr_t        utf8_size(const char *s);
+intptr_t        utf8_size_n(const char *s, intptr_t nbytes);             // number of UTF8 codepoints within n bytes
+const char*     utf8_at(const char *s, intptr_t index);                  // from UTF8 index to char* position
+intptr_t        utf8_pos(const char* s, intptr_t index);                 // from UTF8 index to byte index position
 unsigned        utf8_chr_size(const char* s);                            // UTF8 character size: 1-4
 // implemented in src/utf8code.c:
 bool            utf8_valid(const char* s);
-bool            utf8_valid_n(const char* s, size_t nbytes);
+bool            utf8_valid_n(const char* s, intptr_t nbytes);
 uint32_t        utf8_decode(utf8_decode_t *d, uint8_t byte);             // decode next byte to utf8, return state.
 unsigned        utf8_encode(char *out, uint32_t codepoint);              // encode unicode cp into out buffer
 uint32_t        utf8_peek(const char* s);                                // codepoint value of character at s
@@ -76,11 +76,11 @@ uint32_t        utf8_peek_off(const char* s, int offset);                // code
 
 #### Extended cstr methods
 ```c
-csview          cstr_substr(const cstr* self, size_t pos, size_t n);
-csview          cstr_substr_ex(const cstr* s, intptr_t pos, size_t n);   // negative pos count from end
-csview          cstr_u8_substr(const cstr* self, size_t bytepos, size_t u8len);
+csview          cstr_substr(const cstr* self, intptr_t pos, intptr_t n);
+csview          cstr_substr_ex(const cstr* s, intptr_t pos, intptr_t n);   // negative pos count from end
+csview          cstr_u8_substr(const cstr* self, intptr_t bytepos, intptr_t u8len);
 
-csview          cstr_slice(const cstr* self, size_t p1, size_t p2);
+csview          cstr_slice(const cstr* self, intptr_t p1, intptr_t p2);
 csview          cstr_slice_ex(const cstr* s, intptr_t p, intptr_t q);    // negative p or q count from end
 ```
 #### Iterate tokens with *c_FORTOKEN*, *c_FORTOKEN_SV*
@@ -103,7 +103,7 @@ uint64_t        csview_hash(const csview* x);
 
 | Type name       | Type definition                            | Used to represent...     |
 |:----------------|:-------------------------------------------|:-------------------------|
-| `csview`        | `struct { const char *str; size_t size; }` | The string view type     |
+| `csview`        | `struct { const char *str; intptr_t size; }` | The string view type     |
 | `csview_value`  | `char`                                     | The string element type  |
 | `csview_iter`   | `struct { csview_value *ref; }`            | UTF8 iterator            |
 
@@ -125,7 +125,7 @@ int main ()
                                                         // (quoting Alfred N. Whitehead)
 
     csview sv1 = cstr_substr(&str1, 3, 5);              // "think"
-    size_t pos = cstr_find(&str1, "live");              // position of "live" in str1
+    intptr_t pos = cstr_find(&str1, "live");              // position of "live" in str1
     csview sv2 = cstr_substr(&str1, pos, 4);            // get "live"
     csview sv3 = cstr_slice(&str1, -8, -1);             // get "details"
     printf("%.*s %.*s %.*s\n",
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 08c404af..d67e80fd 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -31,26 +31,26 @@ See the c++ class [std::vector](https://en.cppreference.com/w/cpp/container/vect
 
 ```c
 cvec_X              cvec_X_init(void);
-cvec_X              cvec_X_with_size(size_t size, i_val null);
-cvec_X              cvec_X_with_capacity(size_t size);
+cvec_X              cvec_X_with_size(intptr_t size, i_val null);
+cvec_X              cvec_X_with_capacity(intptr_t size);
 cvec_X              cvec_X_clone(cvec_X vec);
 
 void                cvec_X_clear(cvec_X* self);
 void                cvec_X_copy(cvec_X* self, const cvec_X* other);
 cvec_X_iter         cvec_X_copy_range(cvec_X* self, i_val* pos, const i_val* p1, const i_val* p2);
-bool                cvec_X_reserve(cvec_X* self, size_t cap);
-bool                cvec_X_resize(cvec_X* self, size_t size, i_val null);
-cvec_X_iter         cvec_X_insert_uninit(cvec_X* self, i_val* pos, size_t n);              // return pos iter 
+bool                cvec_X_reserve(cvec_X* self, intptr_t cap);
+bool                cvec_X_resize(cvec_X* self, intptr_t size, i_val null);
+cvec_X_iter         cvec_X_insert_uninit(cvec_X* self, i_val* pos, intptr_t n);              // return pos iter 
 void                cvec_X_shrink_to_fit(cvec_X* self);
 void                cvec_X_drop(cvec_X* self);                                               // destructor
 
 bool                cvec_X_empty(const cvec_X* self);
-size_t              cvec_X_size(const cvec_X* self);
-size_t              cvec_X_capacity(const cvec_X* self);
+intptr_t            cvec_X_size(const cvec_X* self);
+intptr_t            cvec_X_capacity(const cvec_X* self);
 
-const cvec_X_value* cvec_X_at(const cvec_X* self, size_t idx);
+const cvec_X_value* cvec_X_at(const cvec_X* self, intptr_t idx);
 const cvec_X_value* cvec_X_get(const cvec_X* self, i_valraw raw);                            // return NULL if not found
-cvec_X_value*       cvec_X_at_mut(cvec_X* self, size_t idx);
+cvec_X_value*       cvec_X_at_mut(cvec_X* self, intptr_t idx);
 cvec_X_value*       cvec_X_get_mut(cvec_X* self, i_valraw raw);                              // find mutable value, return value ptr
 cvec_X_iter         cvec_X_find(const cvec_X* self, i_valraw raw);
 cvec_X_iter         cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw);            // return cvec_X_end() if not found
@@ -71,18 +71,18 @@ cvec_X_value*       cvec_X_emplace_back(cvec_X* self, i_valraw raw);
 void                cvec_X_pop(cvec_X* self);
 void                cvec_X_pop_back(cvec_X* self);                                           // alias for pop
 
-cvec_X_iter         cvec_X_insert(cvec_X* self, size_t idx, i_val value);                    // move value 
-cvec_X_iter         cvec_X_insert_n(cvec_X* self, size_t idx, const i_val[] arr, size_t n);  // move n values
+cvec_X_iter         cvec_X_insert(cvec_X* self, intptr_t idx, i_val value);                  // move value 
+cvec_X_iter         cvec_X_insert_n(cvec_X* self, intptr_t idx, const i_val[] arr, intptr_t n);  // move n values
 cvec_X_iter         cvec_X_insert_at(cvec_X* self, cvec_X_iter it, i_val value);             // move value 
 cvec_X_iter         cvec_X_insert_range(cvec_X* self, i_val* pos,
                                         const i_val* p1, const i_val* p2);
 
-cvec_X_iter         cvec_X_emplace_n(cvec_X* self, size_t idx, const i_valraw[] arr, size_t n); // clone values
+cvec_X_iter         cvec_X_emplace_n(cvec_X* self, intptr_t idx, const i_valraw[] arr, intptr_t n); // clone values
 cvec_X_iter         cvec_X_emplace_at(cvec_X* self, cvec_X_iter it, i_valraw raw);
 cvec_X_iter         cvec_X_emplace_range(cvec_X* self, i_val* pos,
                                          const i_valraw* p1, const i_valraw* p2);
 
-cvec_X_iter         cvec_X_erase_n(cvec_X* self, size_t idx, size_t n);
+cvec_X_iter         cvec_X_erase_n(cvec_X* self, intptr_t idx, intptr_t n);
 cvec_X_iter         cvec_X_erase_at(cvec_X* self, cvec_X_iter it);
 cvec_X_iter         cvec_X_erase_range(cvec_X* self, cvec_X_iter it1, cvec_X_iter it2);
 cvec_X_iter         cvec_X_erase_range_p(cvec_X* self, i_val* p1, i_val* p2);
@@ -94,7 +94,7 @@ void                cvec_X_sort_range(cvec_X_iter i1, cvec_X_iter i2,
 cvec_X_iter         cvec_X_begin(const cvec_X* self);
 cvec_X_iter         cvec_X_end(const cvec_X* self);
 void                cvec_X_next(cvec_X_iter* iter);
-cvec_X_iter         cvec_X_advance(cvec_X_iter it, intptr_t n);
+cvec_X_iter         cvec_X_advance(cvec_X_iter it, size_t n);
 
 cvec_X_raw          cvec_X_value_toraw(cvec_X_value* pval);
 cvec_X_value        cvec_X_value_clone(cvec_X_value val);