diff --git a/examples/sixdraw.c b/examples/sixdraw.c
index 5fecf54..c32a552 100644
--- a/examples/sixdraw.c
+++ b/examples/sixdraw.c
@@ -38,14 +38,14 @@
 
 #include <ctlseqs.h>
 
-#ifndef SIXDRAW_DEFAULT_TIMEOUT_MILLIS
-#  define SIXDRAW_DEFAULT_TIMEOUT_MILLIS 500
-#endif  // !SIXDRAW_DEFAULT_TIMEOUT_MILLIS
+#ifndef DEFAULT_TIMEOUT_MILLIS
+#  define DEFAULT_TIMEOUT_MILLIS 500
+#endif  // !DEFAULT_TIMEOUT_MILLIS
 
-#define SIXDRAW_DECRQM_SET 1
-#define SIXDRAW_DECRQM_RST 2
-#define SIXDRAW_DECTCEM    25u
-#define SIXDRAW_ALT_SCRBUF 1049u
+#define DECRQM_SET 1
+#define DECRQM_RST 2
+#define DECTCEM    25u
+#define ALT_SCRBUF 1049u
 
 struct sixdraw_ctx {
     struct termios          termios;
@@ -66,7 +66,7 @@ struct sixdraw_ctx {
 };
 
 static inline void
-sixdraw_print_error(struct sixdraw_ctx const *ctx, char const *format, ...)
+print_error(struct sixdraw_ctx const *ctx, char const *format, ...)
 {
     char msg[1024];
     va_list args;
@@ -77,7 +77,7 @@ sixdraw_print_error(struct sixdraw_ctx const *ctx, char const *format, ...)
 }
 
 static inline void
-sixdraw_clear_signal(int signum)
+clear_signal(int signum)
 {
     sigset_t sigset;
     sigemptyset(&sigset);
@@ -86,31 +86,31 @@ sixdraw_clear_signal(int signum)
 }
 
 static bool
-sixdraw_handle_signals(struct sixdraw_ctx *ctx)
+handle_signals(struct sixdraw_ctx *ctx)
 {
     sigset_t sigset;
     sigpending(&sigset);
     if (!sigismember(&sigset, SIGWINCH)) {
         return false;
     }
-    sixdraw_clear_signal(SIGWINCH);
+    clear_signal(SIGWINCH);
     return true;
 }
 
 static void
-sixdraw_terminate(struct sixdraw_ctx *ctx)
+terminate(struct sixdraw_ctx *ctx)
 {
     ctlseqs_matcher_free(ctx->matcher);
     ctlseqs_reader_free(ctx->reader);
 
     // Restore cursor status.
     if (ctx->show_cursor) {
-        dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), SIXDRAW_DECTCEM);
+        dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), DECTCEM);
     }
 
     // Restore normal screen buffer.
     if (ctx->normal_scrbuf) {
-        dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), SIXDRAW_ALT_SCRBUF);
+        dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), ALT_SCRBUF);
     }
 
     // Restore original terminal modes.
@@ -120,15 +120,15 @@ sixdraw_terminate(struct sixdraw_ctx *ctx)
 }
 
 static bool
-sixdraw_get_winsize(struct sixdraw_ctx *ctx)
+get_winsize(struct sixdraw_ctx *ctx)
 {
     struct winsize ws = { 0 };
     if (ioctl(ctx->in_fd, TIOCGWINSZ, &ws) != 0) {
-        sixdraw_print_error(ctx, "failed to get terminal window size");
+        print_error(ctx, "failed to get terminal window size");
         return false;
     }
     if (ws.ws_xpixel == 0 || ws.ws_ypixel == 0) {
-        sixdraw_print_error(ctx, "failed to get terminal window size (in pixels)");
+        print_error(ctx, "failed to get terminal window size (in pixels)");
         return false;
     }
     ctx->rows = ws.ws_row;
@@ -139,7 +139,7 @@ sixdraw_get_winsize(struct sixdraw_ctx *ctx)
 }
 
 static bool
-sixdraw_decrqm(struct sixdraw_ctx *ctx, unsigned mode_id, char const *name)
+decrqm(struct sixdraw_ctx *ctx, unsigned mode_id, char const *name)
 {
     ssize_t retval;
     union ctlseqs_value *result = ctx->result;
@@ -148,24 +148,24 @@ sixdraw_decrqm(struct sixdraw_ctx *ctx, unsigned mode_id, char const *name)
         retval = ctlseqs_read(ctx->reader, ctx->matcher, ctx->timeout);
     } while (retval == CTLSEQS_PARTIAL);
     if (retval != 1) {
-        sixdraw_print_error(ctx, "failed to get %s status", name);
+        print_error(ctx, "failed to get %s status", name);
         return false;
     }
-    if (result[0].num != mode_id || (result[1].num != SIXDRAW_DECRQM_SET && result[1].num != SIXDRAW_DECRQM_RST)) {
-        sixdraw_print_error(ctx, "%s status not recognizable", name);
+    if (result[0].num != mode_id || (result[1].num != DECRQM_SET && result[1].num != DECRQM_RST)) {
+        print_error(ctx, "%s status not recognizable", name);
         return false;
     }
     return true;
 }
 
 static bool
-sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
+init(struct sixdraw_ctx *ctx, int argc, char **argv)
 {
     *ctx = (struct sixdraw_ctx) {
         .prog_name = argc > 0 ? argv[0] : "sixdraw",
         .in_fd     = STDIN_FILENO,
         .out_fd    = STDOUT_FILENO,
-        .timeout   = SIXDRAW_DEFAULT_TIMEOUT_MILLIS,
+        .timeout   = DEFAULT_TIMEOUT_MILLIS,
     };
 
     // Process command line arguments.
@@ -184,7 +184,7 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
     // Initialize control sequence matcher.
     ctx->matcher = ctlseqs_matcher_init();
     if (ctx->matcher == NULL) {
-        sixdraw_print_error(ctx, "failed to initialize matcher");
+        print_error(ctx, "failed to initialize matcher");
         return false;
     }
     char const *patterns[] = {
@@ -196,14 +196,14 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
         .npatterns = sizeof(patterns) / sizeof(char const *),
     };
     if (ctlseqs_matcher_config(ctx->matcher, &matcher_options) != 0) {
-        sixdraw_print_error(ctx, "failed to set matcher options");
+        print_error(ctx, "failed to set matcher options");
         return false;
     }
 
     // Initialize control sequence reader.
     ctx->reader = ctlseqs_reader_init();
     if (ctx->reader == NULL) {
-        sixdraw_print_error(ctx, "failed to initialize reader");
+        print_error(ctx, "failed to initialize reader");
         return false;
     }
     struct ctlseqs_reader_options reader_options = {
@@ -212,7 +212,7 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
         .maxlen = 4096,
     };
     if (ctlseqs_reader_config(ctx->reader, &reader_options) != CTLSEQS_OK) {
-        sixdraw_print_error(ctx, "failed to set reader options");
+        print_error(ctx, "failed to set reader options");
         return false;
     }
 
@@ -227,17 +227,17 @@ sixdraw_init(struct sixdraw_ctx *ctx, int argc, char **argv)
 }
 
 static bool
-sixdraw_prepare(struct sixdraw_ctx *ctx)
+prepare(struct sixdraw_ctx *ctx)
 {
     // Check whether we're running on a terminal.
     if (!isatty(ctx->in_fd) || !isatty(ctx->out_fd)) {
-        sixdraw_print_error(ctx, "this program can only run in a terminal");
+        print_error(ctx, "this program can only run in a terminal");
         return false;
     }
 
     // Set terminal to noncanonical mode.
     if (tcgetattr(ctx->in_fd, &ctx->termios) != 0) {
-        sixdraw_print_error(ctx, "failed to get terminal attributes");
+        print_error(ctx, "failed to get terminal attributes");
         return false;
     }
     struct termios termios = ctx->termios;
@@ -245,7 +245,7 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
     termios.c_cc[VTIME] = 0;
     termios.c_lflag &= ~(ICANON | ISIG | ECHO);
     if (tcsetattr(ctx->in_fd, TCSANOW, &termios) != 0) {
-        sixdraw_print_error(ctx, "failed to set terminal attributes");
+        print_error(ctx, "failed to set terminal attributes");
         return false;
     }
     ctx->has_termios = true;
@@ -253,16 +253,16 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
     // Set STDIN flags to nonblocking.
     int flags = fcntl(ctx->in_fd, F_GETFL);
     if (flags == -1) {
-        sixdraw_print_error(ctx, "failed to get file status flags");
+        print_error(ctx, "failed to get file status flags");
         return false;
     }
     if (fcntl(ctx->in_fd, F_SETFL, flags | O_NONBLOCK) == -1) {
-        sixdraw_print_error(ctx, "failed to set file status flags");
+        print_error(ctx, "failed to set file status flags");
         return false;
     }
 
     // Get initial terminal window size.
-    if (!sixdraw_get_winsize(ctx)) {
+    if (!get_winsize(ctx)) {
         return false;
     }
 
@@ -273,7 +273,7 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
         retval = ctlseqs_read(ctx->reader, ctx->matcher, ctx->timeout);
     } while (retval == CTLSEQS_PARTIAL);
     if (retval != 0) {
-        sixdraw_print_error(ctx, "failed to get terminal features");
+        print_error(ctx, "failed to get terminal features");
         return false;
     }
     bool has_sixel = false;
@@ -287,34 +287,34 @@ sixdraw_prepare(struct sixdraw_ctx *ctx)
         }
     }
     if (!has_sixel) {
-        sixdraw_print_error(ctx, "terminal does not support sixel graphics");
+        print_error(ctx, "terminal does not support sixel graphics");
         return false;
     }
     if (!has_dec_locator) {
-        sixdraw_print_error(ctx, "terminal does not support DEC locator mode");
+        print_error(ctx, "terminal does not support DEC locator mode");
         return false;
     }
 
     // Get current cursor status.
-    if (!sixdraw_decrqm(ctx, SIXDRAW_DECTCEM, "cursor")) {
+    if (!decrqm(ctx, DECTCEM, "cursor")) {
         return false;
     }
-    ctx->show_cursor = result[1].num == SIXDRAW_DECRQM_SET;
+    ctx->show_cursor = result[1].num == DECRQM_SET;
 
     // Hide cursor.
     if (ctx->show_cursor) {
-        dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), SIXDRAW_DECTCEM);
+        dprintf(ctx->out_fd, CTLSEQS_DECRST("%u"), DECTCEM);
     }
 
     // Get current screen buffer status.
-    if (!sixdraw_decrqm(ctx, SIXDRAW_ALT_SCRBUF, "screen buffer")) {
+    if (!decrqm(ctx, ALT_SCRBUF, "screen buffer")) {
         return false;
     }
-    ctx->normal_scrbuf = result[1].num == SIXDRAW_DECRQM_RST;
+    ctx->normal_scrbuf = result[1].num == DECRQM_RST;
 
     // Switch to alternate screen buffer.
     if (ctx->normal_scrbuf) {
-        dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), SIXDRAW_ALT_SCRBUF);
+        dprintf(ctx->out_fd, CTLSEQS_DECSET("%u"), ALT_SCRBUF);
     }
 
     return true;
@@ -326,12 +326,12 @@ main(int argc, char **argv)
     int status = 0;
 
     struct sixdraw_ctx ctx;
-    if (!sixdraw_init(&ctx, argc, argv) || !sixdraw_prepare(&ctx)) {
+    if (!init(&ctx, argc, argv) || !prepare(&ctx)) {
         status = -1;
         goto terminate;
     }
 
     terminate:
-    sixdraw_terminate(&ctx);
+    terminate(&ctx);
     return status;
 }
diff --git a/tests/tcsgrep.c b/tests/tcsgrep.c
index a597d94..03ae2d5 100644
--- a/tests/tcsgrep.c
+++ b/tests/tcsgrep.c
@@ -33,24 +33,26 @@
 
 #include <ctlseqs.h>
 
-#define TCSGREP_NINTH_ARG_(a1, a2, a3, a4, a5, a6, a7, a8, a9, ...) a9
-#define TCSGREP_COUNT_ARGS_(...) TCSGREP_NINTH_ARG_(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+#define NINTH_ARG_(a1, a2, a3, a4, a5, a6, a7, a8, a9, ...) a9
+#define COUNT_ARGS_(...) NINTH_ARG_(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1, 0)
 
-#define TCSGREP_CONCAT_1_(a1)                             a1
-#define TCSGREP_CONCAT_2_(a1, a2)                         a1 a2
-#define TCSGREP_CONCAT_3_(a1, a2, a3)                     a1 a2 a3
-#define TCSGREP_CONCAT_4_(a1, a2, a3, a4)                 a1 a2 a3 a4
-#define TCSGREP_CONCAT_5_(a1, a2, a3, a4, a5)             a1 a2 a3 a4 a5
-#define TCSGREP_CONCAT_6_(a1, a2, a3, a4, a5, a6)         a1 a2 a3 a4 a5 a6
-#define TCSGREP_CONCAT_7_(a1, a2, a3, a4, a5, a6, a7)     a1 a2 a3 a4 a5 a6 a7
-#define TCSGREP_CONCAT_8_(a1, a2, a3, a4, a5, a6, a7, a8) a1 a2 a3 a4 a5 a6 a7 a8
+#define CONCAT_1_(a1)                             a1
+#define CONCAT_2_(a1, a2)                         a1 a2
+#define CONCAT_3_(a1, a2, a3)                     a1 a2 a3
+#define CONCAT_4_(a1, a2, a3, a4)                 a1 a2 a3 a4
+#define CONCAT_5_(a1, a2, a3, a4, a5)             a1 a2 a3 a4 a5
+#define CONCAT_6_(a1, a2, a3, a4, a5, a6)         a1 a2 a3 a4 a5 a6
+#define CONCAT_7_(a1, a2, a3, a4, a5, a6, a7)     a1 a2 a3 a4 a5 a6 a7
+#define CONCAT_8_(a1, a2, a3, a4, a5, a6, a7, a8) a1 a2 a3 a4 a5 a6 a7 a8
 
-#define TCSGREP_CONCAT_(nargs)       TCSGREP_CONCAT_##nargs##_
-#define TCSGREP_DEFARGS_(nargs, ...) TCSGREP_CONCAT_(nargs)(__VA_ARGS__)
+#define CONCAT_(nargs)       CONCAT_##nargs##_
+#define DEFARGS_(nargs, ...) CONCAT_(nargs)(__VA_ARGS__)
 
-#define TCSGREP_DEFSEQ_NOARGS(name)  { #name, CTLSEQS_##name(), "" }
-#define TCSGREP_DEFSEQ(name, ...)    \
-    { #name, CTLSEQS_##name(__VA_ARGS__), TCSGREP_DEFARGS_(TCSGREP_COUNT_ARGS_(__VA_ARGS__), __VA_ARGS__) }
+#define DEFSEQ_NOARGS(name)  { #name, CTLSEQS_##name(), "" }
+#define DEFSEQ(name, ...)    \
+    { #name, CTLSEQS_##name(__VA_ARGS__), DEFARGS_(COUNT_ARGS_(__VA_ARGS__), __VA_ARGS__) }
+
+#define DEFAULT_MAX_BUFFER_LEN 4096
 
 struct tcsgrep_sequence {
     char const *name;
@@ -101,7 +103,7 @@ print_char(int ch)
     } else if (ch == 0x7f) {
         printf(" DEL");
     } else if (!iscntrl(ch)) {
-        printf(" \\x%02x", ch);
+        printf(" \\x%02x", (unsigned char)ch);
     } else {
         printf(" %s", ascii_table[ch]);
     }
@@ -156,7 +158,7 @@ main(int argc, char **argv)
     struct tcsgrep_ctx ctx = {
         .prog_name       = argv[0],
         .timeout         = -1,
-        .limit           = 4096,
+        .limit           = DEFAULT_MAX_BUFFER_LEN,
     };
 
     int opt;
@@ -203,154 +205,154 @@ main(int argc, char **argv)
         return 1;
     }
     static struct tcsgrep_sequence seqs[] = {
-        TCSGREP_DEFSEQ_NOARGS(S7C1T),
-        TCSGREP_DEFSEQ_NOARGS(S8C1T),
-        TCSGREP_DEFSEQ_NOARGS(DECDHL_TOP),
-        TCSGREP_DEFSEQ_NOARGS(DECDHL_BOTOM),
-        TCSGREP_DEFSEQ_NOARGS(DECSWL),
-        TCSGREP_DEFSEQ_NOARGS(DECDWL),
-        TCSGREP_DEFSEQ_NOARGS(DECALN),
-        TCSGREP_DEFSEQ_NOARGS(DECBI),
-        TCSGREP_DEFSEQ_NOARGS(DECSC),
-        TCSGREP_DEFSEQ_NOARGS(DECRC),
-        TCSGREP_DEFSEQ_NOARGS(DECFI),
-        TCSGREP_DEFSEQ_NOARGS(DECKPAM),
-        TCSGREP_DEFSEQ_NOARGS(DECKPNM),
-        TCSGREP_DEFSEQ_NOARGS(RIS),
-        TCSGREP_DEFSEQ(DECUDK, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(DECRQSS, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(DECRSPS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(XTGETXRES, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(XTSETTCAP, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(XTGETTCAP, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(ICH, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(SL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CUU, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CUD, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CUF, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CUB, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CNL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CPL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CHA, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CUP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CHT, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(ED, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSED, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(EL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSEL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(IL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DCH, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(SU, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTSMGRAPHICS, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(SD, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTHIMOUSE, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTRMTITLE, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(ECH, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(CBT, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(HPA, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(HPR, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(REP, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(PRIMARY_DA),
-        TCSGREP_DEFSEQ_NOARGS(TERTIARY_DA),
-        TCSGREP_DEFSEQ_NOARGS(SECONDARY_DA),
-        TCSGREP_DEFSEQ(VPA, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(VPR, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(HVP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(TBC, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(SM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSET, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(MC, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(MC_DEC, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(RM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECRST, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(SGR, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTMODKEYS, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(DSR, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTMODKEYS_DISABLE, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DSR_DEC, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTSMPOINTER, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(DECSTR),
-        TCSGREP_DEFSEQ(DECSCL, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECRQM_ANSI, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECRQM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(XTVERSION),
-        TCSGREP_DEFSEQ(DECLL, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSCUSR, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSCA, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSTBM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTRESTORE, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(DECCARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(SCOSC),
-        TCSGREP_DEFSEQ(DECSLRM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTSAVE, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(XTWINOPS, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(XTSMTITLE, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(DECSWBV, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECRARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(SCORC),
-        TCSGREP_DEFSEQ(DECSMBV, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM,
+        DEFSEQ_NOARGS(S7C1T),
+        DEFSEQ_NOARGS(S8C1T),
+        DEFSEQ_NOARGS(DECDHL_TOP),
+        DEFSEQ_NOARGS(DECDHL_BOTOM),
+        DEFSEQ_NOARGS(DECSWL),
+        DEFSEQ_NOARGS(DECDWL),
+        DEFSEQ_NOARGS(DECALN),
+        DEFSEQ_NOARGS(DECBI),
+        DEFSEQ_NOARGS(DECSC),
+        DEFSEQ_NOARGS(DECRC),
+        DEFSEQ_NOARGS(DECFI),
+        DEFSEQ_NOARGS(DECKPAM),
+        DEFSEQ_NOARGS(DECKPNM),
+        DEFSEQ_NOARGS(RIS),
+        DEFSEQ(DECUDK, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
+        DEFSEQ(DECRQSS, CTLSEQS_PH_STR),
+        DEFSEQ(DECRSPS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
+        DEFSEQ(XTGETXRES, CTLSEQS_PH_STR),
+        DEFSEQ(XTSETTCAP, CTLSEQS_PH_STR),
+        DEFSEQ(XTGETTCAP, CTLSEQS_PH_STR),
+        DEFSEQ(ICH, CTLSEQS_PH_NUM),
+        DEFSEQ(SL, CTLSEQS_PH_NUM),
+        DEFSEQ(CUU, CTLSEQS_PH_NUM),
+        DEFSEQ(CUD, CTLSEQS_PH_NUM),
+        DEFSEQ(CUF, CTLSEQS_PH_NUM),
+        DEFSEQ(CUB, CTLSEQS_PH_NUM),
+        DEFSEQ(CNL, CTLSEQS_PH_NUM),
+        DEFSEQ(CPL, CTLSEQS_PH_NUM),
+        DEFSEQ(CHA, CTLSEQS_PH_NUM),
+        DEFSEQ(CUP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(CHT, CTLSEQS_PH_NUM),
+        DEFSEQ(ED, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSED, CTLSEQS_PH_NUM),
+        DEFSEQ(EL, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSEL, CTLSEQS_PH_NUM),
+        DEFSEQ(IL, CTLSEQS_PH_NUM),
+        DEFSEQ(DL, CTLSEQS_PH_NUM),
+        DEFSEQ(DCH, CTLSEQS_PH_NUM),
+        DEFSEQ(SU, CTLSEQS_PH_NUM),
+        DEFSEQ(XTSMGRAPHICS, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUMS),
+        DEFSEQ(SD, CTLSEQS_PH_NUM),
+        DEFSEQ(XTHIMOUSE, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(XTRMTITLE, CTLSEQS_PH_STR),
+        DEFSEQ(ECH, CTLSEQS_PH_NUM),
+        DEFSEQ(CBT, CTLSEQS_PH_NUM),
+        DEFSEQ(HPA, CTLSEQS_PH_NUM),
+        DEFSEQ(HPR, CTLSEQS_PH_NUM),
+        DEFSEQ(REP, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(PRIMARY_DA),
+        DEFSEQ_NOARGS(TERTIARY_DA),
+        DEFSEQ_NOARGS(SECONDARY_DA),
+        DEFSEQ(VPA, CTLSEQS_PH_NUM),
+        DEFSEQ(VPR, CTLSEQS_PH_NUM),
+        DEFSEQ(HVP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(TBC, CTLSEQS_PH_NUM),
+        DEFSEQ(SM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSET, CTLSEQS_PH_NUM),
+        DEFSEQ(MC, CTLSEQS_PH_NUM),
+        DEFSEQ(MC_DEC, CTLSEQS_PH_NUM),
+        DEFSEQ(RM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECRST, CTLSEQS_PH_NUM),
+        DEFSEQ(SGR, CTLSEQS_PH_NUM),
+        DEFSEQ(XTMODKEYS, CTLSEQS_PH_NUMS),
+        DEFSEQ(DSR, CTLSEQS_PH_NUM),
+        DEFSEQ(XTMODKEYS_DISABLE, CTLSEQS_PH_NUM),
+        DEFSEQ(DSR_DEC, CTLSEQS_PH_NUM),
+        DEFSEQ(XTSMPOINTER, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(DECSTR),
+        DEFSEQ(DECSCL, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECRQM_ANSI, CTLSEQS_PH_NUM),
+        DEFSEQ(DECRQM, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(XTVERSION),
+        DEFSEQ(DECLL, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSCUSR, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSCA, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSTBM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(XTRESTORE, CTLSEQS_PH_NUMS),
+        DEFSEQ(DECCARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(SCOSC),
+        DEFSEQ(DECSLRM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(XTSAVE, CTLSEQS_PH_NUMS),
+        DEFSEQ(XTWINOPS, CTLSEQS_PH_NUMS),
+        DEFSEQ(XTSMTITLE, CTLSEQS_PH_NUMS),
+        DEFSEQ(DECSWBV, CTLSEQS_PH_NUM),
+        DEFSEQ(DECRARA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(SCORC),
+        DEFSEQ(DECSMBV, CTLSEQS_PH_NUM),
+        DEFSEQ(DECCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM,
             CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECRQPSR, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSACE, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECFRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTCHECKSUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM,
+        DEFSEQ(DECRQPSR, CTLSEQS_PH_NUM),
+        DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECEFR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECREQTPARM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSACE, CTLSEQS_PH_NUM),
+        DEFSEQ(DECFRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(XTCHECKSUM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM,
             CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECELR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSLE, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(XTPUSHSGR, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(DECSERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(XTREPORTSGR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECSCPP, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(DECRQLP),
-        TCSGREP_DEFSEQ(DECSNLS, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(XTPOPSGR),
-        TCSGREP_DEFSEQ(DECIC, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(DECDC, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(OSC_SEQ, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_DECRQSS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_XTGETXRES, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_XTGETTCAP, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_PRIMARY_DA, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(RESP_SECONDARY_DA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(RESP_DECXCPR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(RESP_DSR, CTLSEQS_PH_NUMS),
-        TCSGREP_DEFSEQ(RESP_DECRQM_ANSI, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(RESP_DECRQM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ(RESP_XTVERSION, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_DECCIR, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_DECTABSR, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
-        TCSGREP_DEFSEQ(RESP_DECRQLP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
-        TCSGREP_DEFSEQ_NOARGS(KEY_UP),
-        TCSGREP_DEFSEQ_NOARGS(KEY_DOWN),
-        TCSGREP_DEFSEQ_NOARGS(KEY_RIGHT),
-        TCSGREP_DEFSEQ_NOARGS(KEY_LEFT),
-        TCSGREP_DEFSEQ_NOARGS(KEY_HOME),
-        TCSGREP_DEFSEQ_NOARGS(KEY_END),
-        TCSGREP_DEFSEQ_NOARGS(KEY_INSERT),
-        TCSGREP_DEFSEQ_NOARGS(KEY_DELETE),
-        TCSGREP_DEFSEQ_NOARGS(KEY_PGUP),
-        TCSGREP_DEFSEQ_NOARGS(KEY_PGDN),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F1),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F2),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F3),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F4),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F5),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F6),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F7),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F8),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F9),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F10),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F11),
-        TCSGREP_DEFSEQ_NOARGS(KEY_F12),
+        DEFSEQ(DECELR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSLE, CTLSEQS_PH_NUMS),
+        DEFSEQ(XTPUSHSGR, CTLSEQS_PH_NUMS),
+        DEFSEQ(DECSERA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(XTREPORTSGR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(DECSCPP, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(DECRQLP),
+        DEFSEQ(DECSNLS, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(XTPOPSGR),
+        DEFSEQ(DECIC, CTLSEQS_PH_NUM),
+        DEFSEQ(DECDC, CTLSEQS_PH_NUM),
+        DEFSEQ(OSC_SEQ, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_DECRQSS, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_XTGETXRES, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_XTGETTCAP, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_PRIMARY_DA, CTLSEQS_PH_NUMS),
+        DEFSEQ(RESP_SECONDARY_DA, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(RESP_DECXCPR, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(RESP_DSR, CTLSEQS_PH_NUMS),
+        DEFSEQ(RESP_DECRQM_ANSI, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(RESP_DECRQM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ(RESP_XTVERSION, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_DECCIR, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_DECTABSR, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_DECRQCRA, CTLSEQS_PH_NUM, CTLSEQS_PH_STR),
+        DEFSEQ(RESP_DECRQLP, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM, CTLSEQS_PH_NUM),
+        DEFSEQ_NOARGS(KEY_UP),
+        DEFSEQ_NOARGS(KEY_DOWN),
+        DEFSEQ_NOARGS(KEY_RIGHT),
+        DEFSEQ_NOARGS(KEY_LEFT),
+        DEFSEQ_NOARGS(KEY_HOME),
+        DEFSEQ_NOARGS(KEY_END),
+        DEFSEQ_NOARGS(KEY_INSERT),
+        DEFSEQ_NOARGS(KEY_DELETE),
+        DEFSEQ_NOARGS(KEY_PGUP),
+        DEFSEQ_NOARGS(KEY_PGDN),
+        DEFSEQ_NOARGS(KEY_F1),
+        DEFSEQ_NOARGS(KEY_F2),
+        DEFSEQ_NOARGS(KEY_F3),
+        DEFSEQ_NOARGS(KEY_F4),
+        DEFSEQ_NOARGS(KEY_F5),
+        DEFSEQ_NOARGS(KEY_F6),
+        DEFSEQ_NOARGS(KEY_F7),
+        DEFSEQ_NOARGS(KEY_F8),
+        DEFSEQ_NOARGS(KEY_F9),
+        DEFSEQ_NOARGS(KEY_F10),
+        DEFSEQ_NOARGS(KEY_F11),
+        DEFSEQ_NOARGS(KEY_F12),
     };
     size_t npatterns = sizeof(seqs) / sizeof(struct tcsgrep_sequence);
     char const **patterns = malloc(sizeof(char const *) * npatterns);