diff --git a/base.h b/base.h
index d7a88ba..23c93cd 100644
--- a/base.h
+++ b/base.h
@@ -18,8 +18,8 @@ typedef uint32_t U32;
 typedef int32_t I32;
 typedef uint64_t U64;
 typedef int64_t I64;
-typedef size_t USz;
-typedef ssize_t ISz;
+typedef size_t Usz;
+typedef ssize_t Isz;
 
 typedef struct {
   Term* buffer;
diff --git a/field.c b/field.c
index 66169f4..bfe7a21 100644
--- a/field.c
+++ b/field.c
@@ -7,18 +7,18 @@ void field_init(Field* f) {
   f->width = 0;
 }
 
-void field_init_fill(Field* f, USz height, USz width, Term fill_char) {
+void field_init_fill(Field* f, Usz height, Usz width, Term fill_char) {
   assert(height <= ORCA_Y_MAX && width <= ORCA_X_MAX);
-  USz num_cells = height * width;
+  Usz num_cells = height * width;
   f->buffer = malloc(num_cells * sizeof(Term));
   memset(f->buffer, fill_char, num_cells);
   f->height = (U16)height;
   f->width = (U16)width;
 }
 
-void field_resize_raw(Field* f, USz height, USz width) {
+void field_resize_raw(Field* f, Usz height, Usz width) {
   assert(height <= ORCA_Y_MAX && width <= ORCA_X_MAX);
-  USz cells = height * width;
+  Usz cells = height * width;
   f->buffer = realloc(f->buffer, cells * sizeof(Term));
   f->height = (U16)height;
   f->width = (U16)width;
@@ -26,36 +26,36 @@ void field_resize_raw(Field* f, USz height, USz width) {
 
 void field_deinit(Field* f) { free(f->buffer); }
 
-void field_copy_subrect(Field* src, Field* dest, USz src_y, USz src_x,
-                        USz dest_y, USz dest_x, USz height, USz width) {
-  USz src_height = src->height;
-  USz src_width = src->width;
-  USz dest_height = dest->height;
-  USz dest_width = dest->width;
+void field_copy_subrect(Field* src, Field* dest, Usz src_y, Usz src_x,
+                        Usz dest_y, Usz dest_x, Usz height, Usz width) {
+  Usz src_height = src->height;
+  Usz src_width = src->width;
+  Usz dest_height = dest->height;
+  Usz dest_width = dest->width;
   if (src_height <= src_y || src_width <= src_x || dest_height <= dest_y ||
       dest_width <= dest_x)
     return;
-  USz ny_0 = src_height - src_y;
-  USz ny_1 = dest_height - dest_y;
-  USz ny = height;
+  Usz ny_0 = src_height - src_y;
+  Usz ny_1 = dest_height - dest_y;
+  Usz ny = height;
   if (ny_0 < ny)
     ny = ny_0;
   if (ny_1 < ny)
     ny = ny_1;
   if (ny == 0)
     return;
-  USz row_copy_0 = src_width - src_x;
-  USz row_copy_1 = dest_width - dest_x;
-  USz row_copy = width;
+  Usz row_copy_0 = src_width - src_x;
+  Usz row_copy_1 = dest_width - dest_x;
+  Usz row_copy = width;
   if (row_copy_0 < row_copy)
     row_copy = row_copy_0;
   if (row_copy_1 < row_copy)
     row_copy = row_copy_1;
-  USz copy_bytes = row_copy * sizeof(Term);
+  Usz copy_bytes = row_copy * sizeof(Term);
   Term* src_p = src->buffer + src_y * src_width + src_x;
   Term* dest_p = dest->buffer + dest_y * dest_width + dest_x;
-  USz src_stride;
-  USz dest_stride;
+  Usz src_stride;
+  Usz dest_stride;
   if (src_y >= dest_y) {
     src_stride = src_width;
     dest_stride = dest_width;
@@ -65,7 +65,7 @@ void field_copy_subrect(Field* src, Field* dest, USz src_y, USz src_x,
     src_stride = -src_width;
     dest_stride = -dest_width;
   }
-  USz iy = 0;
+  Usz iy = 0;
   for (;;) {
     memmove(dest_p, src_p, copy_bytes);
     ++iy;
@@ -76,25 +76,25 @@ void field_copy_subrect(Field* src, Field* dest, USz src_y, USz src_x,
   }
 }
 
-void field_fill_subrect(Field* f, USz y, USz x, USz height, USz width,
+void field_fill_subrect(Field* f, Usz y, Usz x, Usz height, Usz width,
                         Term fill_char) {
-  USz f_height = f->height;
-  USz f_width = f->width;
+  Usz f_height = f->height;
+  Usz f_width = f->width;
   if (y >= f_height || x >= f_width)
     return;
-  USz rows_0 = f_height - y;
-  USz rows = height;
+  Usz rows_0 = f_height - y;
+  Usz rows = height;
   if (rows_0 < rows)
     rows = rows_0;
   if (rows == 0)
     return;
-  USz columns_0 = f_width - x;
-  USz columns = width;
+  Usz columns_0 = f_width - x;
+  Usz columns = width;
   if (columns_0 < columns)
     columns = columns_0;
-  USz fill_bytes = columns * sizeof(Term);
+  Usz fill_bytes = columns * sizeof(Term);
   Term* p = f->buffer + y * f_width + x;
-  USz iy = 0;
+  Usz iy = 0;
   for (;;) {
     memset(p, fill_char, fill_bytes);
     ++iy;
@@ -104,40 +104,40 @@ void field_fill_subrect(Field* f, USz y, USz x, USz height, USz width,
   }
 }
 
-Term field_peek(Field* f, USz y, USz x) {
-  USz f_height = f->height;
-  USz f_width = f->width;
+Term field_peek(Field* f, Usz y, Usz x) {
+  Usz f_height = f->height;
+  Usz f_width = f->width;
   assert(y < f_height && x < f_width);
   if (y >= f_height || x >= f_width)
     return '\0';
   return f->buffer[y * f_width + x];
 }
 
-Term field_peek_relative(Field* f, USz y, USz x, ISz offs_y, ISz offs_x) {
-  ISz f_height = f->height;
-  ISz f_width = f->width;
-  ISz y0 = (ISz)y + (ISz)offs_y;
-  ISz x0 = (ISz)x + (ISz)offs_x;
+Term field_peek_relative(Field* f, Usz y, Usz x, Isz offs_y, Isz offs_x) {
+  Isz f_height = f->height;
+  Isz f_width = f->width;
+  Isz y0 = (Isz)y + (Isz)offs_y;
+  Isz x0 = (Isz)x + (Isz)offs_x;
   if (y0 >= f_height || x0 >= f_width || y0 < 0 || x0 < 0)
     return '.';
   return f->buffer[y0 * f_width + x0];
 }
 
-void field_poke(Field* f, USz y, USz x, Term term) {
-  USz f_height = f->height;
-  USz f_width = f->width;
+void field_poke(Field* f, Usz y, Usz x, Term term) {
+  Usz f_height = f->height;
+  Usz f_width = f->width;
   assert(y < f_height && x < f_width);
   if (y >= f_height || x >= f_width)
     return;
   f->buffer[y * f_width + x] = term;
 }
 
-void field_poke_relative(Field* f, USz y, USz x, ISz offs_y, ISz offs_x,
+void field_poke_relative(Field* f, Usz y, Usz x, Isz offs_y, Isz offs_x,
                          Term term) {
-  ISz f_height = f->height;
-  ISz f_width = f->width;
-  ISz y0 = (ISz)y + (ISz)offs_y;
-  ISz x0 = (ISz)x + (ISz)offs_x;
+  Isz f_height = f->height;
+  Isz f_width = f->width;
+  Isz y0 = (Isz)y + (Isz)offs_y;
+  Isz x0 = (Isz)x + (Isz)offs_x;
   if (y0 >= f_height || x0 >= f_width || y0 < 0 || x0 < 0)
     return;
   f->buffer[y0 * f_width + x0] = term;
@@ -148,14 +148,14 @@ static inline bool term_char_is_valid(char c) { return c >= '#' && c <= '~'; }
 void field_fput(Field* f, FILE* stream) {
   enum { Column_buffer_count = 4096 };
   char out_buffer[Column_buffer_count];
-  USz f_height = f->height;
-  USz f_width = f->width;
+  Usz f_height = f->height;
+  Usz f_width = f->width;
   Term* f_buffer = f->buffer;
   if (f_width > Column_buffer_count - 2)
     return;
-  for (USz iy = 0; iy < f_height; ++iy) {
+  for (Usz iy = 0; iy < f_height; ++iy) {
     Term* row_p = f_buffer + f_width * iy;
-    for (USz ix = 0; ix < f_width; ++ix) {
+    for (Usz ix = 0; ix < f_width; ++ix) {
       char c = row_p[ix];
       out_buffer[ix] = term_char_is_valid(c) ? c : '!';
     }
@@ -172,8 +172,8 @@ Field_load_error field_load_file(char const* filepath, Field* field) {
   }
   enum { Bufsize = 4096 };
   char buf[Bufsize];
-  USz first_row_columns = 0;
-  USz rows = 0;
+  Usz first_row_columns = 0;
+  Usz rows = 0;
   for (;;) {
     char* s = fgets(buf, Bufsize, file);
     if (s == NULL)
@@ -182,7 +182,7 @@ Field_load_error field_load_file(char const* filepath, Field* field) {
       fclose(file);
       return Field_load_error_too_many_rows;
     }
-    USz len = strlen(buf);
+    Usz len = strlen(buf);
     if (len == Bufsize - 1 && buf[len - 1] != '\n' && !feof(file)) {
       fclose(file);
       return Field_load_error_too_many_columns;
@@ -209,7 +209,7 @@ Field_load_error field_load_file(char const* filepath, Field* field) {
     }
     field_resize_raw(field, rows + 1, first_row_columns);
     Term* rowbuff = field->buffer + first_row_columns * rows;
-    for (USz i = 0; i < len; ++i) {
+    for (Usz i = 0; i < len; ++i) {
       char c = buf[i];
       rowbuff[i] = term_char_is_valid(c) ? c : '.';
     }
diff --git a/field.h b/field.h
index c55ea39..317e794 100644
--- a/field.h
+++ b/field.h
@@ -2,17 +2,17 @@
 #include "base.h"
 
 void field_init(Field* f);
-void field_init_fill(Field* f, USz height, USz width, Term fill_char);
-void field_resize_raw(Field* f, USz height, USz width);
+void field_init_fill(Field* f, Usz height, Usz width, Term fill_char);
+void field_resize_raw(Field* f, Usz height, Usz width);
 void field_deinit(Field* f);
-void field_copy_subrect(Field* src, Field* dest, USz src_y, USz src_x,
-                        USz dest_y, USz dest_x, USz height, USz width);
-void field_fill_subrect(Field* f, USz y, USz x, USz height, USz width,
+void field_copy_subrect(Field* src, Field* dest, Usz src_y, Usz src_x,
+                        Usz dest_y, Usz dest_x, Usz height, Usz width);
+void field_fill_subrect(Field* f, Usz y, Usz x, Usz height, Usz width,
                         Term fill_char);
-Term field_peek(Field* f, USz y, USz x);
-Term field_peek_relative(Field* f, USz y, USz x, ISz offs_y, ISz offs_x);
-void field_poke(Field* f, USz y, USz x, Term term);
-void field_poke_relative(Field* f, USz y, USz x, ISz offs_y, ISz offs_x,
+Term field_peek(Field* f, Usz y, Usz x);
+Term field_peek_relative(Field* f, Usz y, Usz x, Isz offs_y, Isz offs_x);
+void field_poke(Field* f, Usz y, Usz x, Term term);
+void field_poke_relative(Field* f, Usz y, Usz x, Isz offs_y, Isz offs_x,
                          Term term);
 
 void field_fput(Field* f, FILE* stream);
diff --git a/sim.c b/sim.c
index eec1871..a38d09a 100644
--- a/sim.c
+++ b/sim.c
@@ -9,8 +9,8 @@ static Term const indexed_terms[] = {
 
 enum { Terms_array_num = sizeof indexed_terms };
 
-static inline USz index_of_term(Term c) {
-  for (USz i = 0; i < Terms_array_num; ++i) {
+static inline Usz index_of_term(Term c) {
+  for (Usz i = 0; i < Terms_array_num; ++i) {
     if (indexed_terms[i] == c)
       return i;
   }
@@ -24,9 +24,9 @@ static inline Term term_lowered(Term c) {
 // Always returns 0 through (sizeof indexed_terms) - 1, and works on
 // capitalized terms as well. The index of the lower-cased term is returned if
 // the term is capitalized.
-static inline USz semantic_index_of_term(Term c) {
+static inline Usz semantic_index_of_term(Term c) {
   Term c0 = term_lowered(c);
-  for (USz i = 0; i < Terms_array_num; ++i) {
+  for (Usz i = 0; i < Terms_array_num; ++i) {
     if (indexed_terms[i] == c0)
       return i;
   }
@@ -34,18 +34,18 @@ static inline USz semantic_index_of_term(Term c) {
 }
 
 static inline Term terms_sum(Term a, Term b) {
-  USz ia = semantic_index_of_term(a);
-  USz ib = semantic_index_of_term(b);
+  Usz ia = semantic_index_of_term(a);
+  Usz ib = semantic_index_of_term(b);
   return indexed_terms[(ia + ib) % Terms_array_num];
 }
 
 static inline Term terms_mod(Term a, Term b) {
-  USz ia = semantic_index_of_term(a);
-  USz ib = semantic_index_of_term(b);
+  Usz ia = semantic_index_of_term(a);
+  Usz ib = semantic_index_of_term(b);
   return indexed_terms[ib == 0 ? 0 : (ia % ib)];
 }
 
-static inline void act_a(Field* f, USz y, USz x) {
+static inline void act_a(Field* f, Usz y, Usz x) {
   Term inp0 = field_peek_relative(f, y, x, 0, 1);
   Term inp1 = field_peek_relative(f, y, x, 0, 2);
   if (inp0 != '.' && inp1 != '.') {
@@ -54,7 +54,7 @@ static inline void act_a(Field* f, USz y, USz x) {
   }
 }
 
-static inline void act_m(Field* f, USz y, USz x) {
+static inline void act_m(Field* f, Usz y, Usz x) {
   Term inp0 = field_peek_relative(f, y, x, 0, 1);
   Term inp1 = field_peek_relative(f, y, x, 0, 2);
   if (inp0 != '.' && inp1 != '.') {
@@ -64,12 +64,12 @@ static inline void act_m(Field* f, USz y, USz x) {
 }
 
 void orca_run(Field* f) {
-  USz ny = f->height;
-  USz nx = f->width;
+  Usz ny = f->height;
+  Usz nx = f->width;
   Term* f_buffer = f->buffer;
-  for (USz iy = 0; iy < ny; ++iy) {
+  for (Usz iy = 0; iy < ny; ++iy) {
     Term* row = f_buffer + iy * nx;
-    for (USz ix = 0; ix < nx; ++ix) {
+    for (Usz ix = 0; ix < nx; ++ix) {
       Term c = row[ix];
       switch (c) {
       case 'a':