Merge Makefile rewrite into master

# Conflicts:
#	.travis.yml
#	Makefile
#	Makefile-ccan

diff --git a/.travis.yml b/.travis.yml
index 5f2097fd8182a7a084b700571c6cce53bd8c515b..d7b4318ddcde7daabe4da6db7f888d08f79b82bd 100644 (file)
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,7 +8,11 @@ compiler:
 addons:
     apt:
         packages:
-            - libjudy-dev libvorbis-dev libportaudio-dev libtalloc-dev
+            - libjudy-dev
+            - libvorbis-dev
+            - libportaudio-dev
+            - libtalloc-dev
 
 script:
-        - make -j2 -k check quiet=1
+    - make -j2 -k quiet=1
+    - make -k check quiet=1

diff --git a/Makefile b/Makefile
index ff0bad4e91acfd32d7a0e60366850b41b0c23ba8..6559c702a14c911ee024586dfa0f794abfd7b5b5 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -11,6 +11,7 @@ WARN_CFLAGS := -Wall -Wstrict-prototypes -Wold-style-definition -Wundef \
  -Wmissing-prototypes -Wmissing-declarations -Wpointer-arith -Wwrite-strings
 DEP_CFLAGS = -MMD -MP -MF$(@:%=%.d) -MT$@
 CCAN_CFLAGS := -g3 -ggdb $(WARN_CFLAGS) -DCCAN_STR_DEBUG=1 -I. $(CFLAGS)
+CFLAGS_FORCE_C_SOURCE := -x c
 
 # Anything with an _info file is a module ...
 INFO_SRCS := $(wildcard ccan/*/_info ccan/*/*/_info)
@@ -32,7 +33,7 @@ DEPS := $(OBJS:%=%.d)
 
 # _info files are compiled into executables and don't need dependencies
 %info : %_info config.h
-       $(PRE)$(CC) $(CCAN_CFLAGS) -I. -o $@ -x c $<
+       $(PRE)$(CC) $(CCAN_CFLAGS) -I. -o $@ $(CFLAGS_FORCE_C_SOURCE) $<
 
 # config.h is built by configurator which has no ccan dependencies
 CONFIGURATOR := tools/configurator/configurator

diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644 (file)
index 0000000..76a7e4b
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,37 @@
+# AppVeyor CI Configuration
+#
+# Current build status can be viewed at
+# https://ci.appveyor.com/project/dgibson/ccan
+#
+# To build test a fork of this repository using AppVeyor:
+# 1. Visit appveyor.com and create a free account.
+# 2. On the Projects tab, select "New Project" then the project hosting site.
+# 3. Grant OAuth permissions to your project git host.
+# 4. Select the repository for your project fork.
+# 5. Review build results and push updates until the desired result is reached.
+
+version: 0.0.{build}
+
+platform:
+- x86
+- amd64
+
+build_script:
+# Reset %PATH% to avoid msys/cygwin DLL conflicts which cause
+# *** fatal error - cygheap base mismatch detected
+- set PATH=C:\Windows\System32;C:\Windows;C:\Windows\System32\Wbem;C:\msys64\usr\bin
+# Set environment variables for chosen compiler
+- "\"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat\" %Platform%"
+# Ensure config.h can be generated.
+# Note: Dash options avoid POSIX path conversion by msys
+- "make config.h CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash"
+# FIXME:  Work in progress.  Disabled due to unfixed compile errors.
+# FIXME:  -j%NUMBER_OF_PROCESSORS% won't work without DEPGEN for config.h
+#         It may be possible to generate .d from cl using /showIncludes
+#         See https://stackoverflow.com/q/37685069
+#- "make tools CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash"
+#- "make -k CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash"
+
+test_script:
+# FIXME:  Work in progress.  Disabled due to unfixed compile errors.
+#- "make -k check CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash"

diff --git a/ccan/aga/aga.h b/ccan/aga/aga.h
index d09d4c72ba7a2e8d5f98b50f57f275ebcc370cd6..239d36c339ee7bebc73d03ba1b1e4419fb1e0b76 100644 (file)
--- a/ccan/aga/aga.h
+++ b/ccan/aga/aga.h
@@ -165,6 +165,12 @@ struct aga_node {
                        bool complete;
                        struct lpq_link pqlink;
                } dijkstra;
+               struct {
+                       aga_icost_t distance;
+                       struct aga_node *prev;
+                       const void *prevedge;
+                       struct aga_node *list;
+               } bellman_ford;
        } u;
 };
 
@@ -177,6 +183,11 @@ struct aga_graph {
        aga_edge_info_fn edge_info;
        union {
                LPQ(struct aga_node, u.dijkstra.pqlink) dijkstra;
+               struct {
+                       struct aga_node *nodelist;
+                       int nnodes;
+                       int npasses;
+               } bellman_ford;
        } state;
 };
 
@@ -347,7 +358,7 @@ struct aga_node *aga_bfs_explore(struct aga_graph *g, struct aga_node *n);
  *
  * Performs a breadth first search.  The block following this macro is
  * executed with @_n set first to @_start, then to each node reachable
- * from @_start in depth first search order.
+ * from @_start in breadth-first search order.
  *
  * aga_bfs_start() must be called before this macro is used.
  */
@@ -416,15 +427,74 @@ bool aga_dijkstra_path(struct aga_graph *g, struct aga_node *dest,
                       struct aga_node **prev, const void **prevedge);
 
 /**
- * aga_dijkstra_all_paths - Find shortest paths to all reachable nodes
+ * aga_dijkstra_complete - Find shortest paths to all reachable nodes
  * @g: graph
  *
  * Finds shortest paths from the source node (specified in
  * aga_dijkstra_start()) to all other reachable nodes in @g.  No
  * results are returned directly, but between calling
- * aga_dijkstra_all_paths() and aga_finish, aga_dijkstra_path() is
+ * aga_dijkstra_all_paths() and aga_finish(), aga_dijkstra_path() is
  * guaranteed to complete in O(1) time for all destinations.
  */
-void aga_dijkstra_all_paths(struct aga_graph *g);
+void aga_dijkstra_complete(struct aga_graph *g);
+
+/*
+ * Bellman-Ford algorithm
+ */
+
+/**
+ * aga_bellman_ford_start - Start Bellman-Ford algorithm
+ * @g: graph
+ * @source: source node
+ *
+ * Start's the Bellman-Ford algorithm on @g to find shortest paths
+ * from node @source, to other nodes in @g.
+ */
+int aga_bellman_ford_start(struct aga_graph *g, struct aga_node *source);
+
+/**
+ * aga_bellman_ford_path - Find the shortest path to a node
+ * @g: graph
+ * @dest: destination node
+ * @prev: Second last node in the path *output)
+ * @prevedge: Last edge in the path
+ *
+ * Finds the shortest path from the source node (specified in
+ * aga_bellman_ford_start() to @dest using Bellman_Ford's algorithm.
+ *
+ * If no path exists, return false.
+ *
+ * If a path does exist, returns true.  Additionally if @total_cost is
+ * non-NULL, store the total cost of the path in *@total_cost, if
+ * @prev is non-NULL, store the node in the path immediately before
+ * @dest in *@prev and if @prevedge is non-NULL stores the edge which
+ * leads from *@prev to @dest in *@prevedge.
+ *
+ * If @dest is the same as source, 0 will be stored in @cost, and NULL
+ * will be stored in *@prev and *@prevedge.
+ *
+ * The full path from source to @dest can be determined by repeatedly
+ * calling aga_bellman_ford_path() on *@prev.
+ *
+ * NOTE: Bellman_Ford's algorithm will not work correctly on a graph
+ * which contains a cycle with (total) negative cost.  If aga detects
+ * this case, it will set aga_error() to AGA_ERR_NEGATIVE_COST.
+ */
+bool aga_bellman_ford_path(struct aga_graph *g, struct aga_node *dest,
+                          aga_icost_t *total_cost,
+                          struct aga_node **prev, const void **prevedge);
+
+/**
+ * aga_bellman_ford_complete - Run Bellman-Ford algorithm to completion
+ * @g: graph
+ *
+ * Finds shortest paths from the source node (specified in
+ * aga_bellman_ford_start()) to all other reachable nodes in @g.  No
+ * results are returned directly, but between calling
+ * aga_bellman_ford_complete() and aga_finish(),
+ * aga_bellman_ford_path() is guaranteed to complete in O(1) time for
+ * all destinations.
+ */
+void aga_bellman_ford_complete(struct aga_graph *g);
 
 #endif /* CCAN_AGA_H */

diff --git a/ccan/aga/bellman_ford.c b/ccan/aga/bellman_ford.c
new file mode 100644 (file)
index 0000000..1820483
--- /dev/null
+++ b/ccan/aga/bellman_ford.c
@@ -0,0 +1,141 @@
+/* Licensed under LGPLv2+ - see LICENSE file for details */
+#include "config.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include <ccan/build_assert/build_assert.h>
+#include <ccan/check_type/check_type.h>
+#include <ccan/order/order.h>
+
+#include <ccan/aga/aga.h>
+#include "private.h"
+
+/*
+ * The Bellman-Ford algorithm
+ */
+
+static bool candidate_path(struct aga_graph *g, struct aga_node *node,
+                          aga_icost_t distance,
+                          struct aga_node *prev, const void *prevedge)
+{
+       if (aga_update_node(g, node)) {
+               /* New node, treat as having infinite distance */
+               node->u.bellman_ford.distance = distance;
+               node->u.bellman_ford.prev = prev;
+               node->u.bellman_ford.prevedge = prevedge;
+
+               node->u.bellman_ford.list = g->state.bellman_ford.nodelist;
+               g->state.bellman_ford.nodelist = node;
+               g->state.bellman_ford.nnodes++;
+
+               return true;
+       } else if (distance < node->u.bellman_ford.distance) {
+               node->u.bellman_ford.distance = distance;
+               node->u.bellman_ford.prev = prev;
+               node->u.bellman_ford.prevedge = prevedge;
+       }
+       return false;
+}
+
+int aga_bellman_ford_start(struct aga_graph *g, struct aga_node *source)
+{
+       int rc;
+
+       /* Make sure we're actually using the right ordering for
+        * aga_icost_t */
+       BUILD_ASSERT(check_types_match(long, aga_icost_t) == 0);
+
+       rc = aga_start(g);
+       if (rc < 0)
+               return rc;
+
+       g->state.bellman_ford.nodelist = NULL;
+       g->state.bellman_ford.nnodes = 0;
+       g->state.bellman_ford.npasses = 0;
+
+       candidate_path(g, source, 0, NULL, NULL);
+
+       return 0;
+}
+
+static bool aga_bellman_ford_step(struct aga_graph *g)
+{
+       struct aga_node *n;
+       const void *e;
+       struct aga_edge_info ei;
+       int err;
+       bool newnode = false;
+
+       if (!aga_check_state(g))
+               return false;
+
+       for (n = g->state.bellman_ford.nodelist;
+            n; n = n->u.bellman_ford.list) {
+               aga_for_each_edge_info(e, ei, err, g, n) {
+                       aga_icost_t dist = n->u.bellman_ford.distance
+                               + ei.icost;
+                       newnode = newnode || candidate_path(g, ei.to, dist, n, e);
+               }
+               if (err) {
+                       aga_fail(g, err);
+                       return false;
+               }
+       }
+       g->state.bellman_ford.npasses++;
+       return newnode || (g->state.bellman_ford.npasses
+                          < g->state.bellman_ford.nnodes);
+}
+
+void aga_bellman_ford_complete(struct aga_graph *g)
+{
+       struct aga_node *n;
+       const void *e;
+       struct aga_edge_info ei;
+       int err;
+
+       if (!aga_check_state(g))
+               return;
+
+       while (aga_bellman_ford_step(g))
+               ;
+
+       /* Check for negative cycles */
+       for (n = g->state.bellman_ford.nodelist;
+            n; n = n->u.bellman_ford.list) {
+               aga_for_each_edge_info(e, ei, err, g, n) {
+                       if ((n->u.bellman_ford.distance + ei.icost)
+                           < ei.to->u.bellman_ford.distance) {
+                               aga_fail(g, AGA_ERR_NEGATIVE_COST);
+                               return;
+                       }
+               }
+               if (err) {
+                       aga_fail(g, err);
+                       return;
+               }
+       }
+}
+
+bool aga_bellman_ford_path(struct aga_graph *g, struct aga_node *node,
+                          aga_icost_t *total_cost,
+                          struct aga_node **prev, const void **prevedge)
+{
+       aga_bellman_ford_complete(g);
+
+       if (!aga_check_state(g))
+               return false;
+
+       if (aga_node_needs_update(g, node))
+               return false;
+
+       if (total_cost)
+               *total_cost = node->u.bellman_ford.distance;
+       if (prev)
+               *prev = node->u.bellman_ford.prev;
+       if (prevedge)
+               *prevedge = node->u.bellman_ford.prevedge;
+
+       return true;
+}

diff --git a/ccan/aga/dijkstra.c b/ccan/aga/dijkstra.c
index 02177fb8415a82cf1d3095792484c898d70558bb..cbb79b90779596c6f7c56e0cae18ebee107aeb7b 100644 (file)
--- a/ccan/aga/dijkstra.c
+++ b/ccan/aga/dijkstra.c
@@ -114,7 +114,7 @@ bool aga_dijkstra_path(struct aga_graph *g, struct aga_node *node,
        return true;
 }
 
-void aga_dijkstra_all_paths(struct aga_graph *g)
+void aga_dijkstra_complete(struct aga_graph *g)
 {
        if (!aga_check_state(g))
                return;

diff --git a/ccan/aga/test/api-adjacency.c b/ccan/aga/test/api-adjacency.c
index 6e5043017788272e6aa8f2b07163e49277d71c34..3168522401018b751eb5b2daa70792d863af2963 100644 (file)
--- a/ccan/aga/test/api-adjacency.c
+++ b/ccan/aga/test/api-adjacency.c
@@ -63,8 +63,9 @@ int main(void)
        struct traversal1_graph t1g;
        struct shortcut1_graph s1g;
        struct shortcut2_graph s2g;
+       struct negacycle_graph ng;
 
-       plan_tests(2 + 7 + 35 + 30 + 30 + 42 + 9 + 30 + 9 + 9);
+       plan_tests(2 + 7 + 35 + 30 + 30 + 42 + 9 + 30 + 9 + 9 + 9);
 
        trivial_graph_init(&tg);
        test_adjacency("trivial", &tg.sg, trivial_adjacency);
@@ -99,5 +100,8 @@ int main(void)
        shortcut2_graph_init(&s2g);
        test_adjacency("shortcut2 graph", &s2g.sg, shortcut2_adjacency);
 
+       negacycle_graph_init(&ng);
+       test_adjacency("negacycle graph", &ng.sg, negacycle_adjacency);
+
        return exit_status();
 }

diff --git a/ccan/aga/test/api-bellman_ford.c b/ccan/aga/test/api-bellman_ford.c
new file mode 100644 (file)
index 0000000..5dc032a
--- /dev/null
+++ b/ccan/aga/test/api-bellman_ford.c
@@ -0,0 +1,279 @@
+#include "config.h"
+
+#include <stddef.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include <ccan/tap/tap.h>
+#include <ccan/array_size/array_size.h>
+
+#include <ccan/aga/aga.h>
+
+#include "simple-graph.h"
+
+static void test_trivial(void)
+{
+       struct trivial_graph tg;
+       aga_icost_t cost;
+       struct aga_node *node;
+       const void *edge;
+
+       trivial_graph_init(&tg);
+
+       ok1(aga_bellman_ford_start(&tg.sg.g, &tg.sg.nodes[1]) == 0);
+       ok1(aga_bellman_ford_path(&tg.sg.g, &tg.sg.nodes[1], &cost, &node, &edge));
+       ok1(cost == 0);
+       ok1(node == NULL);
+       ok1(edge == NULL);
+       aga_finish(&tg.sg.g);
+}
+
+static void test_parallel(void)
+{
+       struct parallel_graph pg;
+       aga_icost_t cost;
+       struct aga_node *node;
+       const void *edge;
+
+       parallel_graph_init(&pg, 3, 0);
+
+       ok1(aga_bellman_ford_start(&pg.sg.g, &pg.sg.nodes[1]) == 0);
+       ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[1], &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[2], &cost, &node, NULL));
+       ok1(cost == 2);
+       ok1(node == &pg.sg.nodes[1]);
+       aga_finish(&pg.sg.g);
+
+       ok1(aga_bellman_ford_start(&pg.sg.g, &pg.sg.nodes[2]) == 0);
+       ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[2], &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(!aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[1], NULL, NULL, NULL));
+       aga_finish(&pg.sg.g);
+
+
+       parallel_graph_init(&pg, 3, 2);
+       ok1(aga_bellman_ford_start(&pg.sg.g, &pg.sg.nodes[1]) == 0);
+       ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[2], &cost, &node, &edge));
+       ok1(cost == 1);
+       ok1(node == &pg.sg.nodes[1]);
+       ok1(ptr2int(edge) == 2);
+       aga_finish(&pg.sg.g);
+}
+
+#define FULL_LEN       4
+
+static void test_full(void)
+{
+       struct full_graph fg;
+       int i, j;
+
+       full_graph_init(&fg, FULL_LEN);
+
+       for (i = 1; i <= FULL_LEN; i++) {
+               ok1(aga_bellman_ford_start(&fg.sg.g, &fg.sg.nodes[i]) == 0);
+
+               for (j = 1; j <= FULL_LEN; j++) {
+                       aga_icost_t cost;
+                       struct aga_node *node;
+                       const void *edge;
+
+                       ok1(aga_bellman_ford_path(&fg.sg.g, &fg.sg.nodes[j],
+                                             &cost, &node, &edge));
+                       if (i == j) {
+                               ok1(cost == 0);
+                               ok1(node == NULL);
+                               ok1(edge == NULL);
+                       } else {
+                               ok1(cost == 1);
+                               ok1(node == &fg.sg.nodes[i]);
+                               ok1(edge == &fg.sg.nodes[j]);
+                       }
+               }
+
+               aga_finish(&fg.sg.g);
+       }
+}
+
+#define CHAIN_LEN      8
+
+static void test_chain(void)
+{
+       struct chain_graph cg;
+       int i, j;
+
+       chain_graph_init(&cg, CHAIN_LEN);
+
+       for (i = 1; i <= CHAIN_LEN; i++) {
+               ok1(aga_bellman_ford_start(&cg.fg.sg.g, &cg.fg.sg.nodes[i]) == 0);
+
+               for (j = 1; j <= CHAIN_LEN; j++) {
+                       aga_icost_t cost;
+
+                       ok1(aga_bellman_ford_path(&cg.fg.sg.g, &cg.fg.sg.nodes[j],
+                                             &cost, NULL, NULL));
+                       ok1(cost == labs(i - j));
+               }
+
+               aga_finish(&cg.fg.sg.g);
+       }
+}
+
+static void test_error(void)
+{
+       struct error_graph eg;
+       aga_icost_t cost;
+
+       error_graph_init(&eg);
+
+       ok1(aga_bellman_ford_start(&eg.sg.g, &eg.sg.nodes[1]) == 0);
+       ok1(aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[1], &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[2], &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(!aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[3], &cost, NULL, NULL));
+       ok1(!aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[4], &cost, NULL, NULL));
+       aga_finish(&eg.sg.g);
+
+       ok1(aga_bellman_ford_start(&eg.sg.g, &eg.sg.nodes[3]) == 0);
+       aga_bellman_ford_complete(&eg.sg.g);
+       ok1(!aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[4], &cost, NULL, NULL));
+       ok1(aga_error(&eg.sg.g) == -1);
+       aga_finish(&eg.sg.g);
+}
+
+static void test_traversal1(void)
+{
+       struct traversal1_graph t1g;
+       aga_icost_t cost;
+
+       /* This is mostly about testing we correctly handle
+        * non-reachable nodes */
+       traversal1_graph_init(&t1g);
+
+       ok1(aga_bellman_ford_start(&t1g.sg.g, &t1g.sg.nodes[1]) == 0);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[1],
+                             &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[2],
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[3],
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[4],
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[5],
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[6],
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[7],
+                              NULL, NULL, NULL));
+       ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[8],
+                              NULL, NULL, NULL));
+       ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[9],
+                              NULL, NULL, NULL));
+       aga_finish(&t1g.sg.g);
+
+       ok1(aga_bellman_ford_start(&t1g.sg.g, &t1g.sg.nodes[9]) == 0);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[9],
+                             &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[8],
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[7],
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[6],
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[5],
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[4],
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[3],
+                              NULL, NULL, NULL));
+       ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[2],
+                              NULL, NULL, NULL));
+       ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[1],
+                              NULL, NULL, NULL));
+       aga_finish(&t1g.sg.g);
+}
+
+static void test_shortcut1(void)
+{
+       struct shortcut1_graph s1g;
+       aga_icost_t cost;
+       struct aga_node *node;
+
+       shortcut1_graph_init(&s1g);
+
+       ok1(aga_bellman_ford_start(&s1g.sg.g, &s1g.sg.nodes[1]) == 0);
+       ok1(aga_bellman_ford_path(&s1g.sg.g, &s1g.sg.nodes[3],
+                             &cost, &node, NULL));
+       ok1(cost == 2);
+       ok1(node == &s1g.sg.nodes[2]);
+       ok1(aga_bellman_ford_path(&s1g.sg.g, &s1g.sg.nodes[2],
+                             &cost, &node, NULL));
+       ok1(cost == 1);
+       ok1(node == &s1g.sg.nodes[1]);
+       aga_finish(&s1g.sg.g);
+}
+
+static void test_shortcut2(void)
+{
+       struct shortcut2_graph s2g;
+       aga_icost_t cost;
+       struct aga_node *node;
+
+       shortcut2_graph_init(&s2g);
+
+       ok1(aga_bellman_ford_start(&s2g.sg.g, &s2g.sg.nodes[1]) == 0);
+       ok1(aga_bellman_ford_path(&s2g.sg.g, &s2g.sg.nodes[3],
+                                 &cost, &node, NULL));
+       ok1(cost == 1);
+       ok1(node == &s2g.sg.nodes[2]);
+       ok1(aga_bellman_ford_path(&s2g.sg.g, &s2g.sg.nodes[2],
+                             &cost, &node, NULL));
+       ok1(cost == 2);
+       ok1(node == &s2g.sg.nodes[1]);
+       aga_finish(&s2g.sg.g);
+}
+
+static void test_negacycle(void)
+{
+       struct negacycle_graph ng;
+
+       negacycle_graph_init(&ng);
+
+       ok1(aga_bellman_ford_start(&ng.sg.g, &ng.sg.nodes[1]) == 0);
+       aga_bellman_ford_complete(&ng.sg.g);
+       ok1(aga_error(&ng.sg.g) == AGA_ERR_NEGATIVE_COST);
+       aga_finish(&ng.sg.g);
+}
+
+int main(void)
+{
+       plan_tests(5 + 15
+                  + FULL_LEN * (1 + FULL_LEN * 4)
+                  + CHAIN_LEN * (1 + CHAIN_LEN * 2)
+                  + 10 + 32 + 7 + 7 + 2);
+
+       test_trivial();
+       test_parallel();
+       test_full();
+       test_chain();
+       test_error();
+       test_traversal1();
+       test_shortcut1();
+       test_shortcut2();
+       test_negacycle();
+       
+       return exit_status();
+}

diff --git a/ccan/aga/test/api-bfs.c b/ccan/aga/test/api-bfs.c
index 90fcc62853887595093ce9fff22cc055124d2f23..1a3e1411a229f1ea2b90ba96cea568136b57e565 100644 (file)
--- a/ccan/aga/test/api-bfs.c
+++ b/ccan/aga/test/api-bfs.c
@@ -42,9 +42,10 @@ int main(void)
        struct grid_graph gg1, gg2;
        struct error_graph eg;
        struct traversal1_graph t1g;
+       struct negacycle_graph ng;
        struct aga_node *node;
        
-       plan_tests(2 * 13 + 10 + 10);
+       plan_tests(2 * 13 + 10 + 10 + 6);
 
        trivial_graph_init(&tg);
        test_bfs(&tg.sg, 1, 1);
@@ -100,5 +101,10 @@ int main(void)
        test_bfs_partial(&t1g.sg, 1, 1, 2, 3);
        aga_finish(&t1g.sg.g);
 
+       negacycle_graph_init(&ng);
+       test_bfs(&ng.sg, 1, 1, 2, 3);
+       test_bfs(&ng.sg, 2, 2, 3, 1);
+       test_bfs(&ng.sg, 3, 3, 1, 2);
+       
        return exit_status();
 }

diff --git a/ccan/aga/test/api-dfs.c b/ccan/aga/test/api-dfs.c
index 24d1a4f912078551fbb9faa0161e047fc88f2ef5..c28097a690dcc1687f9273837bd61e6591134527 100644 (file)
--- a/ccan/aga/test/api-dfs.c
+++ b/ccan/aga/test/api-dfs.c
@@ -42,9 +42,10 @@ int main(void)
        struct grid_graph gg1, gg2;
        struct error_graph eg;
        struct traversal1_graph t1g;
+       struct negacycle_graph ng;
        struct aga_node *node;
        
-       plan_tests(2 * 13 + 10 + 10);
+       plan_tests(2 * 13 + 10 + 10 + 6);
 
        trivial_graph_init(&tg);
        test_dfs(&tg.sg, 1, 1);
@@ -100,5 +101,10 @@ int main(void)
        test_dfs_partial(&t1g.sg, 1, 1, 2, 3);
        aga_finish(&t1g.sg.g);
 
+       negacycle_graph_init(&ng);
+       test_dfs(&ng.sg, 1, 1, 2, 3);
+       test_dfs(&ng.sg, 2, 2, 3, 1);
+       test_dfs(&ng.sg, 3, 3, 1, 2);
+
        return exit_status();
 }

diff --git a/ccan/aga/test/api-dijkstra.c b/ccan/aga/test/api-dijkstra.c
index f9b8d764a7d6e198d23797afa404882b0009e8d6..01bb5aa4d880f579ea4c60dd3f51a64a14a9657d 100644 (file)
--- a/ccan/aga/test/api-dijkstra.c
+++ b/ccan/aga/test/api-dijkstra.c
@@ -241,17 +241,29 @@ static void test_shortcut2(void)
        shortcut2_graph_init(&s2g);
 
        ok1(aga_dijkstra_start(&s2g.sg.g, &s2g.sg.nodes[1]) == 0);
-       aga_dijkstra_all_paths(&s2g.sg.g);
+       aga_dijkstra_complete(&s2g.sg.g);
        ok1(aga_error(&s2g.sg.g) == AGA_ERR_NEGATIVE_COST);
        aga_finish(&s2g.sg.g);
 }
 
+static void test_negacycle(void)
+{
+       struct negacycle_graph ng;
+
+       negacycle_graph_init(&ng);
+
+       ok1(aga_dijkstra_start(&ng.sg.g, &ng.sg.nodes[1]) == 0);
+       aga_dijkstra_complete(&ng.sg.g);
+       ok1(aga_error(&ng.sg.g) == AGA_ERR_NEGATIVE_COST);
+       aga_finish(&ng.sg.g);
+}
+
 int main(void)
 {
        plan_tests(7 + 20
                   + FULL_LEN * (1 + FULL_LEN*4)
                   + CHAIN_LEN * (1 + CHAIN_LEN*2)
-                  + 12 + 32 + 7 + 2);
+                  + 12 + 32 + 7 + 2 + 2);
 
        test_trivial();
        test_parallel();
@@ -261,6 +273,7 @@ int main(void)
        test_traversal1();
        test_shortcut1();
        test_shortcut2();
+       test_negacycle();
        
        return exit_status();
 }

diff --git a/ccan/aga/test/negacycle.c b/ccan/aga/test/negacycle.c
new file mode 100644 (file)
index 0000000..8eae4bf
--- /dev/null
+++ b/ccan/aga/test/negacycle.c
@@ -0,0 +1,46 @@
+#include "config.h"
+
+#include <assert.h>
+
+#include <ccan/container_of/container_of.h>
+#include <ccan/ptrint/ptrint.h>
+
+#include <ccan/aga/aga.h>
+
+#include "simple-graph.h"
+
+static ptrint_t *negacycle_first_edge(const struct aga_graph *g,
+                                     const struct aga_node *n)
+{
+       return int2ptr(1);
+}
+
+static ptrint_t *negacycle_next_edge(const struct aga_graph *g,
+                                    const struct aga_node *n,
+                                    ptrint_t *e)
+{
+       assert(ptr2int(e) == 1);
+       return NULL;
+}
+
+static int negacycle_edge_info(const struct aga_graph *g,
+                              const struct aga_node *n,
+                              ptrint_t *e, struct aga_edge_info *ei)
+{
+       struct negacycle_graph *ng = container_of(g, struct negacycle_graph,
+                                                  sg.g);
+       int ni = n - ng->sg.nodes;
+
+       assert(ptr2int(e) == 1);
+       ei->to = &ng->sg.nodes[(ni % 3) + 1];
+       if (ni == 3)
+               ei->icost = -3;
+       return 0;
+}
+
+void negacycle_graph_init(struct negacycle_graph *ng)
+{
+       simple_graph_init(&ng->sg, negacycle_first_edge,
+                         negacycle_next_edge,
+                         negacycle_edge_info);
+}

diff --git a/ccan/aga/test/simple-graph.h b/ccan/aga/test/simple-graph.h
index b8da3ad999045bc9207b59871a56fae691a13120..5808993ac2c203364c73b6ffdbbf8f09ebfc95fd 100644 (file)
--- a/ccan/aga/test/simple-graph.h
+++ b/ccan/aga/test/simple-graph.h
@@ -256,4 +256,23 @@ static const struct adjacency_list shortcut2_adjacency[] = {
        {},
 };
 
+/* Negacycle graph
+ *
+ *  A <---- (-3) ----- C
+ *   \                 ^
+ *    (1)->  B -- (1)-/
+ *
+ * Graph with a negative length cycle, and so lacking well-defined shortest paths.
+ */
+struct negacycle_graph {
+       struct simple_graph sg;
+};
+void negacycle_graph_init(struct negacycle_graph *ng);
+static const struct adjacency_list negacycle_adjacency[] = {
+       {1, {2}},
+       {2, {3}},
+       {3, {1}},
+       {},
+};
+
 #endif /* _TEST_GRAPHS_H */

diff --git a/ccan/agar/agar.c b/ccan/agar/agar.c
index e930d7aa6c7eeabde50110474502b087b78f05ae..aa4628404864affe29578122fb69f729f1a059c8 100644 (file)
--- a/ccan/agar/agar.c
+++ b/ccan/agar/agar.c
@@ -286,8 +286,53 @@ bool agar_dijkstra_path(struct agar_state *sr, const void *destr,
        return true;
 }
 
-void agar_dijkstra_all_paths(struct agar_state *sr)
+void agar_dijkstra_complete(struct agar_state *sr)
 {
-       aga_dijkstra_all_paths(&sr->g);
+       aga_dijkstra_complete(&sr->g);
 }
 
+
+/*
+ * Bellman-Ford algorithm
+ */
+
+struct agar_state *agar_bellman_ford_new(void *ctx, struct agar_graph *gr,
+                                        const void *nr)
+{
+       struct agar_state *sr = agar_new(ctx, gr);
+
+       if (aga_bellman_ford_start(&sr->g, nr_to_n(sr, nr)) < 0) {
+               tal_free(sr);
+               return NULL;
+       }
+
+       return sr;
+}
+
+bool agar_bellman_ford_path(struct agar_state *sr, const void *destr,
+                           aga_icost_t *total_cost,
+                           const void **prevr, const void **prevedge)
+{
+       struct aga_node *dest = nr_to_n(sr, destr);
+       struct aga_node *prev;
+
+       if (!aga_bellman_ford_path(&sr->g, dest, total_cost, &prev, prevedge))
+               return false;
+
+       /*
+        * When destr is the same as the source node, there obviously
+        * isn't a previous node or edge.  In that case aga sets them
+        * to NULL.  But for agar, NULL could be a valid node
+        * references (particularly if using ptrint).  So we don't
+        * have much choice here but to leave *prevr as undefined when
+        * destr is the source node. */
+       if (prevr && prev)
+               *prevr = n_to_nr(sr, prev);
+
+       return true;
+}
+
+void agar_bellman_ford_complete(struct agar_state *sr)
+{
+       aga_bellman_ford_complete(&sr->g);
+}

diff --git a/ccan/agar/agar.h b/ccan/agar/agar.h
index abd11301e6f86abafabfdd5563e5ae9f4b67ddb8..f65b4e371f456d7b6bca8208dd5e7f53260874c2 100644 (file)
--- a/ccan/agar/agar.h
+++ b/ccan/agar/agar.h
@@ -84,6 +84,18 @@ bool agar_dijkstra_step(struct agar_state *sr, const void **nextr);
 bool agar_dijkstra_path(struct agar_state *sr, const void *destr,
                        aga_icost_t *total_cost,
                        const void **prevr, const void **prevedge);
-void agar_dijkstra_all_paths(struct agar_state *sr);
+void agar_dijkstra_complete(struct agar_state *sr);
+
+/*
+ * Bellman-Ford algorithm
+ */
+
+struct agar_state *agar_bellman_ford_new(void *ctx, struct agar_graph *gr,
+                                        const void *nr);
+
+bool agar_bellman_ford_path(struct agar_state *sr, const void *destr,
+                           aga_icost_t *total_cost,
+                           const void **prevr, const void **prevedge);
+void agar_bellman_ford_complete(struct agar_state *sr);
 
 #endif /* CCAN_AGAR_H */

diff --git a/ccan/agar/test/api-bellman_ford.c b/ccan/agar/test/api-bellman_ford.c
new file mode 100644 (file)
index 0000000..a161b0c
--- /dev/null
+++ b/ccan/agar/test/api-bellman_ford.c
@@ -0,0 +1,260 @@
+#include "config.h"
+
+#include <stddef.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#include <ccan/tap/tap.h>
+#include <ccan/tal/tal.h>
+#include <ccan/array_size/array_size.h>
+
+#include <ccan/agar/agar.h>
+
+#include "simple-graphr.h"
+
+static void test_trivial(void)
+{
+       struct agar_state *sr;
+       aga_icost_t cost;
+
+       ok1(sr = agar_bellman_ford_new(NULL, &trivial_graphr.gr, int2ptr(1)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(1), &cost, NULL, NULL));
+       ok1(cost == 0);
+       tal_free(sr);
+}
+
+static void test_parallel(void)
+{
+       struct parallel_graphr pgr;
+       struct agar_state *sr;
+       aga_icost_t cost;
+       const void *node, *edge;
+
+       parallel_graphr_init(&pgr, 3, 0);
+
+       ok1(sr = agar_bellman_ford_new(NULL, &pgr.gr, int2ptr(1)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(1), &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, NULL));
+       ok1(cost == 2);
+       ok1(node == int2ptr(1));
+       tal_free(sr);
+
+       ok1(sr = agar_bellman_ford_new(NULL, &pgr.gr, int2ptr(2)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(!agar_bellman_ford_path(sr, int2ptr(1), NULL, NULL, NULL));
+       tal_free(sr);
+
+       parallel_graphr_init(&pgr, 3, 2);
+       ok1(sr = agar_bellman_ford_new(NULL, &pgr.gr, int2ptr(1)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, &edge));
+       ok1(cost == 1);
+       ok1(ptr2int(node) == 1);
+       ok1(ptr2int(edge) == 2);
+       tal_free(sr);
+}
+
+#define FULL_LEN       4
+
+static void test_full(void)
+{
+       struct full_graphr fgr;
+       int i, j;
+
+       full_graphr_init(&fgr, FULL_LEN);
+
+       for (i = 1; i <= FULL_LEN; i++) {
+               struct agar_state *sr;
+
+               ok1(sr = agar_bellman_ford_new(NULL, &fgr.gr, int2ptr(i)));
+
+               for (j = 1; j <= FULL_LEN; j++) {
+                       aga_icost_t cost;
+                       const void *node, *edge;
+
+                       ok1(agar_bellman_ford_path(sr, int2ptr(j),
+                                             &cost, &node, &edge));
+                       if (i == j) {
+                               ok1(cost == 0);
+                       } else {
+                               ok1(cost == 1);
+                               ok1(node == int2ptr(i));
+                               ok1(edge == int2ptr(j));
+                       }
+               }
+
+               tal_free(sr);
+       }
+}
+
+#define CHAIN_LEN      8
+
+static void test_chain(void)
+{
+       struct chain_graphr cgr;
+       int i, j;
+
+       chain_graphr_init(&cgr, CHAIN_LEN);
+
+       for (i = 1; i <= CHAIN_LEN; i++) {
+               struct agar_state *sr;
+
+               ok1(sr = agar_bellman_ford_new(NULL, &cgr.fgr.gr, int2ptr(i)));
+
+               for (j = 1; j <= CHAIN_LEN; j++) {
+                       aga_icost_t cost;
+
+                       ok1(agar_bellman_ford_path(sr, int2ptr(j),
+                                             &cost, NULL, NULL));
+                       ok1(cost == labs(i - j));
+               }
+
+               tal_free(sr);
+       }
+}
+
+static void test_error(void)
+{
+       struct agar_state *sr;
+       aga_icost_t cost;
+
+       ok1(sr = agar_bellman_ford_new(NULL, &error_graphr.gr, int2ptr(1)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(1), &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(!agar_bellman_ford_path(sr, int2ptr(3), &cost, NULL, NULL));
+       ok1(!agar_bellman_ford_path(sr, int2ptr(4), &cost, NULL, NULL));
+       tal_free(sr);
+
+       ok1(sr = agar_bellman_ford_new(NULL, &error_graphr.gr, int2ptr(3)));
+       agar_bellman_ford_complete(sr);
+       ok1(!agar_bellman_ford_path(sr, int2ptr(4), &cost, NULL, NULL));
+       ok1(agar_error(sr) == -1);
+       tal_free(sr);
+}
+
+static void test_traversal1(void)
+{
+       struct agar_state *sr;
+       aga_icost_t cost;
+
+       /* This is mostly about testing we correctly handle
+        * non-reachable nodes */
+       ok1(sr = agar_bellman_ford_new(NULL, &traversal1_graphr.gr, int2ptr(1)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(1),
+                             &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(agar_bellman_ford_path(sr, int2ptr(2),
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(agar_bellman_ford_path(sr, int2ptr(3),
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(agar_bellman_ford_path(sr, int2ptr(4),
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(agar_bellman_ford_path(sr, int2ptr(5),
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(agar_bellman_ford_path(sr, int2ptr(6),
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(!agar_bellman_ford_path(sr, int2ptr(7),
+                              NULL, NULL, NULL));
+       ok1(!agar_bellman_ford_path(sr, int2ptr(8),
+                              NULL, NULL, NULL));
+       ok1(!agar_bellman_ford_path(sr, int2ptr(9),
+                              NULL, NULL, NULL));
+       tal_free(sr);
+
+       ok1(sr = agar_bellman_ford_new(NULL, &traversal1_graphr.gr, int2ptr(9)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(9),
+                             &cost, NULL, NULL));
+       ok1(cost == 0);
+       ok1(agar_bellman_ford_path(sr, int2ptr(8),
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(agar_bellman_ford_path(sr, int2ptr(7),
+                             &cost, NULL, NULL));
+       ok1(cost == 1);
+       ok1(agar_bellman_ford_path(sr, int2ptr(6),
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(agar_bellman_ford_path(sr, int2ptr(5),
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(agar_bellman_ford_path(sr, int2ptr(4),
+                             &cost, NULL, NULL));
+       ok1(cost == 2);
+       ok1(!agar_bellman_ford_path(sr, int2ptr(3),
+                              NULL, NULL, NULL));
+       ok1(!agar_bellman_ford_path(sr, int2ptr(2),
+                              NULL, NULL, NULL));
+       ok1(!agar_bellman_ford_path(sr, int2ptr(1),
+                              NULL, NULL, NULL));
+       tal_free(sr);
+}
+
+static void test_shortcut1(void)
+{
+       struct agar_state *sr;
+       aga_icost_t cost;
+       const void *node;
+
+       ok1(sr = agar_bellman_ford_new(NULL, &shortcut1_graphr.gr, int2ptr(1)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(3), &cost, &node, NULL));
+       ok1(cost == 2);
+       ok1(node == int2ptr(2));
+       ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, NULL));
+       ok1(cost == 1);
+       ok1(node == int2ptr(1));
+       tal_free(sr);
+}
+
+static void test_shortcut2(void)
+{
+       struct agar_state *sr;
+       aga_icost_t cost;
+       const void *node;
+
+       ok1(sr = agar_bellman_ford_new(NULL, &shortcut2_graphr.gr, int2ptr(1)));
+       ok1(agar_bellman_ford_path(sr, int2ptr(3), &cost, &node, NULL));
+       ok1(cost == 1);
+       ok1(node == int2ptr(2));
+       ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, NULL));
+       ok1(cost == 2);
+       ok1(node == int2ptr(1));
+       tal_free(sr);   
+}
+
+static void test_negacycle(void)
+{
+       struct agar_state *sr;
+
+       ok1(sr = agar_bellman_ford_new(NULL, &negacycle_graphr.gr, int2ptr(1)));
+       agar_bellman_ford_complete(sr);
+       ok1(agar_error(sr) == AGA_ERR_NEGATIVE_COST);
+       tal_free(sr);
+}
+
+int main(void)
+{
+       plan_tests(3 + 15
+                  + FULL_LEN * (FULL_LEN*4 - 1)
+                  + CHAIN_LEN * (1 + CHAIN_LEN*2)
+                  + 10 + 32 + 7 + 7 + 2);
+
+       test_trivial();
+       test_parallel();
+       test_full();
+       test_chain();
+       test_error();
+       test_traversal1();
+       test_shortcut1();
+       test_shortcut2();
+       test_negacycle();
+       
+       return exit_status();
+}

diff --git a/ccan/agar/test/api-bfs.c b/ccan/agar/test/api-bfs.c
index 27369b6e76f19b73e83ac1ec681beec53935b28e..79ea21ad71ee041a5a31ea0fab3729d52a7997f8 100644 (file)
--- a/ccan/agar/test/api-bfs.c
+++ b/ccan/agar/test/api-bfs.c
@@ -45,7 +45,7 @@ int main(void)
        struct agar_state *sr;
        const void *nr;
        
-       plan_tests(2 * 13 + 12 + 10);
+       plan_tests(2 * 13 + 12 + 10 + 6);
 
        test_bfs(&trivial_graphr.gr, 1, 1);
 
@@ -97,5 +97,9 @@ int main(void)
        test_bfs_partial(sr, 1, 1, 2, 3);
        tal_free(sr);
 
+       test_bfs(&negacycle_graphr.gr, 1, 1, 2, 3);
+       test_bfs(&negacycle_graphr.gr, 2, 2, 3, 1);
+       test_bfs(&negacycle_graphr.gr, 3, 3, 1, 2);
+
        return exit_status();
 }

diff --git a/ccan/agar/test/api-dfs.c b/ccan/agar/test/api-dfs.c
index 625e825c3fac07f63c75001f9795a186b531a6d2..65be2e18353f4ee39eb31442da9a1f202d2b0007 100644 (file)
--- a/ccan/agar/test/api-dfs.c
+++ b/ccan/agar/test/api-dfs.c
@@ -45,7 +45,7 @@ int main(void)
        struct agar_state *sr;
        const void *nr;
        
-       plan_tests(2 * 13 + 12 + 10);
+       plan_tests(2 * 13 + 12 + 10 + 6);
 
        test_dfs(&trivial_graphr.gr, 1, 1);
 
@@ -97,5 +97,9 @@ int main(void)
        test_dfs_partial(sr, 1, 1, 2, 3);
        tal_free(sr);
 
+       test_dfs(&negacycle_graphr.gr, 1, 1, 2, 3);
+       test_dfs(&negacycle_graphr.gr, 2, 2, 3, 1);
+       test_dfs(&negacycle_graphr.gr, 3, 3, 1, 2);
+
        return exit_status();
 }

diff --git a/ccan/agar/test/api-dijkstra.c b/ccan/agar/test/api-dijkstra.c
index ebdbf42d1a72d1a180c1441205e448d349943f7d..19980919bd7ca059db2a4287ac8aaf318f407148 100644 (file)
--- a/ccan/agar/test/api-dijkstra.c
+++ b/ccan/agar/test/api-dijkstra.c
@@ -231,7 +231,17 @@ static void test_shortcut2(void)
        struct agar_state *sr;
 
        ok1(sr = agar_dijkstra_new(NULL, &shortcut2_graphr.gr, int2ptr(1)));
-       agar_dijkstra_all_paths(sr);
+       agar_dijkstra_complete(sr);
+       ok1(agar_error(sr) == AGA_ERR_NEGATIVE_COST);
+       tal_free(sr);
+}
+
+static void test_negacycle(void)
+{
+       struct agar_state *sr;
+
+       ok1(sr = agar_dijkstra_new(NULL, &negacycle_graphr.gr, int2ptr(1)));
+       agar_dijkstra_complete(sr);
        ok1(agar_error(sr) == AGA_ERR_NEGATIVE_COST);
        tal_free(sr);
 }
@@ -241,7 +251,7 @@ int main(void)
        plan_tests(6 + 23
                   + FULL_LEN * (FULL_LEN*4 - 1)
                   + CHAIN_LEN * (1 + CHAIN_LEN*2)
-                  + 12 + 32 + 7 + 2);
+                  + 12 + 32 + 7 + 2 + 2);
 
        test_trivial();
        test_parallel();
@@ -251,6 +261,7 @@ int main(void)
        test_traversal1();
        test_shortcut1();
        test_shortcut2();
+       test_negacycle();
        
        return exit_status();
 }

diff --git a/ccan/agar/test/negacycle.c b/ccan/agar/test/negacycle.c
new file mode 100644 (file)
index 0000000..7d3daa9
--- /dev/null
+++ b/ccan/agar/test/negacycle.c
@@ -0,0 +1,42 @@
+#include "config.h"
+
+#include <assert.h>
+
+#include <ccan/container_of/container_of.h>
+#include <ccan/ptrint/ptrint.h>
+
+#include <ccan/agar/agar.h>
+
+#include "simple-graphr.h"
+
+static const void *negacycle_first_edge_r(const struct agar_graph *gr,
+                                         const void *nr)
+{
+       return int2ptr(1);
+}
+
+static const void *negacycle_next_edge_r(const struct agar_graph *gr,
+                                        const void *nr, const void *e)
+{
+       assert(ptr2int(e) == 1);
+       return NULL;
+}
+
+static int negacycle_edge_info_r(const struct agar_graph *gr,
+                                const void *nr, const void *e,
+                                struct agar_edge_info *eir)
+{
+       int ni = ptr2int(nr);
+
+       assert(ptr2int(e) == 1);
+       eir->to = int2ptr((ni % 3) + 1);
+       if (ni == 3)
+               eir->icost = -3;
+       return 0;
+}
+
+struct negacycle_graphr negacycle_graphr = {
+       AGAR_INIT_GRAPH(negacycle_first_edge_r,
+                       negacycle_next_edge_r,
+                       negacycle_edge_info_r),
+};

diff --git a/ccan/agar/test/simple-graphr.h b/ccan/agar/test/simple-graphr.h
index ddb1edbcbd58a5603d9858d36a62671d2f4fcc6a..21cae6a3497c9900ba010dd445f4acdd6203f649 100644 (file)
--- a/ccan/agar/test/simple-graphr.h
+++ b/ccan/agar/test/simple-graphr.h
@@ -240,4 +240,23 @@ static const struct adjacency_listr shortcut2_adjacencyr[] = {
        {},
 };
 
+/* Negacycle graph
+ *
+ *  A <---- (-3) ----- C
+ *   \                 ^
+ *    (1)->  B -- (1)-/
+ *
+ * Graph with a negative length cycle, and so lacking well-defined shortest paths.
+ */
+struct negacycle_graphr {
+       struct agar_graph gr;
+};
+extern struct negacycle_graphr negacycle_graphr;
+static const struct adjacency_listr negacycle_adjacencyr[] = {
+       {1, {2}},
+       {2, {3}},
+       {3, {1}},
+       {},
+};
+
 #endif /* _SIMPLE_GRAPHR_H */

diff --git a/ccan/alignof/_info b/ccan/alignof/_info
index e0952c652810b5a3cdadd0597d2e9aa74ec003ef..ee2b7ad0f28057a73c464b5f59b25c3eb78b3073 100644 (file)
--- a/ccan/alignof/_info
+++ b/ccan/alignof/_info
@@ -21,7 +21,7 @@
  *
  *     // Output contains "ALIGNOF(char) == 1"
  *     // Will also print out whether an onstack char array can hold a long.
- *     int main(int argc, char *argv[])
+ *     int main(void)
  *     {
  *             char arr[sizeof(int)];
  *

diff --git a/ccan/alignof/test/run.c b/ccan/alignof/test/run.c
index f36113d18fded305b364f98f5ddd94701be5b660..5e3216f1708e61000c76f135aaa759749f6452d3 100644 (file)
--- a/ccan/alignof/test/run.c
+++ b/ccan/alignof/test/run.c
@@ -24,7 +24,7 @@ struct lots_of_types
        char c5;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct lots_of_types lots_of_types, *lp = malloc(sizeof(*lp));
        char c;

diff --git a/ccan/array_size/test/compile_fail-function-param.c b/ccan/array_size/test/compile_fail-function-param.c
index 48697e044ec797ada4e6c77cddc91159363975db..164c826f551681549232867b259a5ac16ce5a56e 100644 (file)
--- a/ccan/array_size/test/compile_fail-function-param.c
+++ b/ccan/array_size/test/compile_fail-function-param.c
@@ -18,7 +18,7 @@ int check_parameter(const struct foo *array)
 #endif
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        return check_parameter(NULL);
 }

diff --git a/ccan/array_size/test/compile_fail.c b/ccan/array_size/test/compile_fail.c
index 37d315f2198c59c083cdc81c3c1e057538a123bd..9bd656826dc72d38eaeaff82f5887737df30b2bb 100644 (file)
--- a/ccan/array_size/test/compile_fail.c
+++ b/ccan/array_size/test/compile_fail.c
@@ -2,6 +2,8 @@
 
 int main(int argc, char *argv[8])
 {
+       (void)argc;
+       (void)argv;
        char array[100];
 #ifdef FAIL
        return ARRAY_SIZE(argv) + ARRAY_SIZE(array);

diff --git a/ccan/array_size/test/run.c b/ccan/array_size/test/run.c
index 37b4200b44f363340616da82e20ce2df44388d25..3c4ae1893cca09f384ed634897c09f535881e017 100644 (file)
--- a/ccan/array_size/test/run.c
+++ b/ccan/array_size/test/run.c
@@ -16,7 +16,7 @@ static int array2_size = ARRAY_SIZE(array2);
 static int array3_size = ARRAY_SIZE(array3);
 static int array4_size = ARRAY_SIZE(array4);
 
-int main(int argc, char *argv[])
+int main(void)
 {
        plan_tests(8);
        ok1(array1_size == 1);

diff --git a/ccan/asort/_info b/ccan/asort/_info
index 28e2faebecb3edfcc8e3eff487b99c59cc219401..4d59bec1a7a58d05af0fe4ca8c28f018207a2615 100644 (file)
--- a/ccan/asort/_info
+++ b/ccan/asort/_info
@@ -31,7 +31,7 @@
  *     int main(int argc, char *argv[])
  *     {
  *             bool casefold = false;
- *             unsigned int i;
+ *             int i;
  *     
  *             if (argc < 2) {
  *                     fprintf(stderr, "Usage: %s [-i] <list>...\n"

diff --git a/ccan/asort/test/compile_fail-context-type.c b/ccan/asort/test/compile_fail-context-type.c
index 473d10264140e04710be1a98f02e353a726a9d77..aa2340f4e22b8bf8c8e133f854889c8ef1dffc5b 100644 (file)
--- a/ccan/asort/test/compile_fail-context-type.c
+++ b/ccan/asort/test/compile_fail-context-type.c
@@ -1,7 +1,7 @@
 #include <ccan/asort/asort.h>
 #include <ccan/asort/asort.c>
 
-static int cmp(char *const *a, char *const *b, int *flag)
+static int cmp(char *const *a UNNEEDED, char *const *b UNNEEDED, int *flag UNNEEDED)
 {
        return 0;
 }

diff --git a/ccan/autodata/autodata.c b/ccan/autodata/autodata.c
index d8ea88feae962e28fb4735bbc823824052f8c197..e8086e3abceaa661ecbcf67cb6353d75f8249b32 100644 (file)
--- a/ccan/autodata/autodata.c
+++ b/ccan/autodata/autodata.c
@@ -11,7 +11,7 @@ void *autodata_get_section(void *start, void *stop, size_t *nump)
        return start;
 }
 
-void autodata_free(void *table)
+void autodata_free(void *table UNNEEDED)
 {
 }
 #else

diff --git a/ccan/build_assert/test/compile_fail-expr.c b/ccan/build_assert/test/compile_fail-expr.c
index 109215b8aa7eab11de86a00b2c174ba9a5cfb721..6322eb3523a2e951c0835d6223773002b50f82df 100644 (file)
--- a/ccan/build_assert/test/compile_fail-expr.c
+++ b/ccan/build_assert/test/compile_fail-expr.c
@@ -1,6 +1,6 @@
 #include <ccan/build_assert/build_assert.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        return BUILD_ASSERT_OR_ZERO(1 == 0);

diff --git a/ccan/build_assert/test/compile_fail.c b/ccan/build_assert/test/compile_fail.c
index 37d95eddc9b8d979476a3a921e86e793c7a1dfa7..9fd827d6aef87b7bcec2e234d5cbb9ccb8b8bdfb 100644 (file)
--- a/ccan/build_assert/test/compile_fail.c
+++ b/ccan/build_assert/test/compile_fail.c
@@ -1,6 +1,6 @@
 #include <ccan/build_assert/build_assert.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        BUILD_ASSERT(1 == 0);

diff --git a/ccan/build_assert/test/compile_ok.c b/ccan/build_assert/test/compile_ok.c
index 4105484d1fe35f113a83e32474ad1a57db50c8c8..b4de8b41402d6938fd7cf83b782c8de84904d2b1 100644 (file)
--- a/ccan/build_assert/test/compile_ok.c
+++ b/ccan/build_assert/test/compile_ok.c
@@ -1,6 +1,6 @@
 #include <ccan/build_assert/build_assert.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        BUILD_ASSERT(1 == 1);
        return 0;

diff --git a/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c b/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c
index 418582133179268f0d70ca6ab8fbd8715d72f5d9..72f9ad1ba478fe246775d4327c4c57d24cc2f309 100644 (file)
--- a/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c
+++ b/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c
@@ -1,7 +1,7 @@
 #include <ccan/build_assert/build_assert.h>
 #include <ccan/tap/tap.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        plan_tests(1);
        ok1(BUILD_ASSERT_OR_ZERO(1 == 1) == 0);

diff --git a/ccan/cast/_info b/ccan/cast/_info
index b09e0344e49d6ee570e9b70dbbe98e75393d8847..29128b8d5cf7cff915b07fa01783c2c44727073f 100644 (file)
--- a/ccan/cast/_info
+++ b/ccan/cast/_info
@@ -24,6 +24,7 @@
  *     #include <ccan/cast/cast.h>
  *     #include <stdint.h>
  *     #include <stdio.h>
+ *     #include <stdlib.h>
  *
  *     // Find char @orig in @str, if @repl, replace them.  Return number.
  *     static size_t find_chars(char *str, char orig, char repl)
@@ -53,6 +54,9 @@
  *     {
  *             uint64_t hash;
  *
+ *             if (argc != 2) {
+ *                     fprintf(stderr, "Needs argument\n"); exit(1);
+ *             }
  *             // find_chars wants a non-const string, but doesn't
  *             // need it if repl == 0.
  *             printf("%zu %c's in 'test string'\n",

diff --git a/ccan/cast/test/compile_fail-cast_const.c b/ccan/cast/test/compile_fail-cast_const.c
index 277f3de1c442b21fd9a8953b560a97d5bbb80e58..24ee4b1f00140ac662c8026e37b3adf1b5996b7b 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_const.c
+++ b/ccan/cast/test/compile_fail-cast_const.c
@@ -6,7 +6,7 @@ struct char_struct {
        char c;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *uc;
        const

diff --git a/ccan/cast/test/compile_fail-cast_const2.c b/ccan/cast/test/compile_fail-cast_const2.c
index e671e88eda56ca3dfdfab58bf3cd299fe4627e86..b780f5282f15f1da9ca6c2c03e09826cbccab199 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_const2.c
+++ b/ccan/cast/test/compile_fail-cast_const2.c
@@ -6,7 +6,7 @@ struct char_struct {
        char c;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char **uc;
        const

diff --git a/ccan/cast/test/compile_fail-cast_const3.c b/ccan/cast/test/compile_fail-cast_const3.c
index e958e2dde5b61c485f63be5008c3ac5137733ecc..ac7462c58e2cd7f244225980733b40df3a03f375 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_const3.c
+++ b/ccan/cast/test/compile_fail-cast_const3.c
@@ -6,7 +6,7 @@ struct char_struct {
        char c;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char ***uc;
        const

diff --git a/ccan/cast/test/compile_fail-cast_signed-const.c b/ccan/cast/test/compile_fail-cast_signed-const.c
index 9971dc8eb320cbdc1fc3cfcde2c71b34ea51f6ad..26bf8974ea48d6e82e6dda4de0f71f6f0878bd9e 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_signed-const.c
+++ b/ccan/cast/test/compile_fail-cast_signed-const.c
@@ -1,7 +1,7 @@
 #include <ccan/cast/cast.h>
 #include <stdlib.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned char *uc;
 #ifdef FAIL

diff --git a/ccan/cast/test/compile_fail-cast_signed-sizesame.c b/ccan/cast/test/compile_fail-cast_signed-sizesame.c
index 2bc40b2f462b0ece7254eb671ed8c80f6167816a..b6bbd28386361a6130bb0a0fe8999d2f95530376 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_signed-sizesame.c
+++ b/ccan/cast/test/compile_fail-cast_signed-sizesame.c
@@ -6,7 +6,7 @@ struct char_struct {
        char c;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned char *uc;
 #ifdef FAIL

diff --git a/ccan/cast/test/compile_fail-cast_signed.c b/ccan/cast/test/compile_fail-cast_signed.c
index 66bcc0a1b5ef6f6bed57d9870d81ce00cebb5b50..7661bac46e9afe8031ea6a485cf68d91222690e0 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_signed.c
+++ b/ccan/cast/test/compile_fail-cast_signed.c
@@ -1,7 +1,7 @@
 #include <ccan/cast/cast.h>
 #include <stdlib.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned char *uc;
 #ifdef FAIL

diff --git a/ccan/cast/test/compile_fail-cast_static-2.c b/ccan/cast/test/compile_fail-cast_static-2.c
index 8a1202538455ecc4a30b96bd352f843e1d6c07d3..dae0231e81b2efdee5fb02ed5a33f64a47dafd1c 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_static-2.c
+++ b/ccan/cast/test/compile_fail-cast_static-2.c
@@ -1,7 +1,7 @@
 #include <ccan/cast/cast.h>
 #include <stdlib.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *c;
 #ifdef FAIL

diff --git a/ccan/cast/test/compile_fail-cast_static-3.c b/ccan/cast/test/compile_fail-cast_static-3.c
index 6296b752769822d1880e72d5bf3570f82170bed4..7cd52fc7a39cb478a80fd728e7342b01d48232c4 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_static-3.c
+++ b/ccan/cast/test/compile_fail-cast_static-3.c
@@ -1,7 +1,7 @@
 #include <ccan/cast/cast.h>
 #include <stdlib.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *c;
 #ifdef FAIL

diff --git a/ccan/cast/test/compile_fail-cast_static.c b/ccan/cast/test/compile_fail-cast_static.c
index a4ebf61b1ae66549a792771ca1085701b9efce0b..91d0940bfea470e1c24007c1ea3c9cd378d9b48d 100644 (file)
--- a/ccan/cast/test/compile_fail-cast_static.c
+++ b/ccan/cast/test/compile_fail-cast_static.c
@@ -1,7 +1,7 @@
 #include <ccan/cast/cast.h>
 #include <stdlib.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        long c;
 #ifdef FAIL

diff --git a/ccan/cast/test/compile_ok-static.c b/ccan/cast/test/compile_ok-static.c
index 98b667e83440f36020856fdcb89a00c171a29549..a7c65725ba0924553d586a2eac5f990c1aa78b9d 100644 (file)
--- a/ccan/cast/test/compile_ok-static.c
+++ b/ccan/cast/test/compile_ok-static.c
@@ -6,5 +6,6 @@ static char *p = cast_const(char *, (const char *)"hello");
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
        return p[0] == argv[0][0];
 }

diff --git a/ccan/cdump/_info b/ccan/cdump/_info
index 02ba19b5b3fb0d0b9d4ebe8a009195c6895e930e..c79d013b2c8a08ebb7bb826bd8c40ad2f64e4591 100644 (file)
--- a/ccan/cdump/_info
+++ b/ccan/cdump/_info
@@ -29,7 +29,8 @@
  * {
  *     char *code, *problems;
  *     struct cdump_definitions *defs;
- *     int i, j;
+ *     int i;
+ *     size_t j;
  *
  *     // Read code from stdin.
  *     code = grab_file(NULL, NULL);

diff --git a/ccan/cdump/cdump.c b/ccan/cdump/cdump.c
index 85c818a6df7508db2365efaa952366daa11f8af5..7e42dbd74dc6d328186680598a6b364b2c957bb9 100644 (file)
--- a/ccan/cdump/cdump.c
+++ b/ccan/cdump/cdump.c
@@ -213,7 +213,7 @@ static struct cdump_type *get_type(struct cdump_definitions *defs,
                                   enum cdump_type_kind kind,
                                   const char *name)
 {
-       cdump_map_t *m;
+       cdump_map_t *m = (void *)0x1L; /* Shouldn't be used */
        struct cdump_type *t;
 
        switch (kind) {

diff --git a/ccan/check_type/test/compile_fail-check_type.c b/ccan/check_type/test/compile_fail-check_type.c
index fe7d6a235c33011040bfe9648e98916c69418ce4..4c22c65a499c5df7252444549fb3efe56d70a51b 100644 (file)
--- a/ccan/check_type/test/compile_fail-check_type.c
+++ b/ccan/check_type/test/compile_fail-check_type.c
@@ -2,6 +2,8 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
+       (void)argv;
 #ifdef FAIL
        check_type(argc, char);
 #endif

diff --git a/ccan/check_type/test/compile_fail-check_type_unsigned.c b/ccan/check_type/test/compile_fail-check_type_unsigned.c
index 574d4aeb2402cf3f5ac6d0e7c3a1fe11a3e3de79..795e7606701955440ebd81e816946f36abecbcc8 100644 (file)
--- a/ccan/check_type/test/compile_fail-check_type_unsigned.c
+++ b/ccan/check_type/test/compile_fail-check_type_unsigned.c
@@ -2,6 +2,8 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
+       (void)argv;
 #ifdef FAIL
 #if HAVE_TYPEOF
        check_type(argc, unsigned int);

diff --git a/ccan/check_type/test/compile_fail-check_types_match.c b/ccan/check_type/test/compile_fail-check_types_match.c
index cbd6e9bc5b45fd79739b8bdebd9b3a68c5b3dca3..fb83738b90aba585aedb6c749709b93054c7b9a1 100644 (file)
--- a/ccan/check_type/test/compile_fail-check_types_match.c
+++ b/ccan/check_type/test/compile_fail-check_types_match.c
@@ -3,6 +3,7 @@
 int main(int argc, char *argv[])
 {
        unsigned char x = argc;
+       (void)argv;
 #ifdef FAIL
        check_types_match(argc, x);
 #endif

diff --git a/ccan/check_type/test/run.c b/ccan/check_type/test/run.c
index 83b903c0b1b33314b3cefae512299de9f59986bb..09fd3634376fc078d3d62df5b465e54f0a2db4cd 100644 (file)
--- a/ccan/check_type/test/run.c
+++ b/ccan/check_type/test/run.c
@@ -5,6 +5,7 @@ int main(int argc, char *argv[])
 {
        int x = 0, y = 0;
 
+       (void)argv;
        plan_tests(9);
 
        ok1(check_type(argc, int) == 0);

diff --git a/ccan/compiler/_info b/ccan/compiler/_info
index d60dff4d17bb0a50b691bb83097debdc94f38cf5..12cb24757829b55d339ed6f9e540834d84eac9d3 100644 (file)
--- a/ccan/compiler/_info
+++ b/ccan/compiler/_info
@@ -41,7 +41,7 @@
  *             va_end(ap);
  *     }
  *
- *     int main(int argc, char *argv[])
+ *     int main(int argc, char *argv[] UNNEEDED)
  *     {
  *             if (argc != 1) {
  *                     logger(3, "Don't want %i arguments!\n", argc-1);

diff --git a/ccan/compiler/test/compile_fail-printf.c b/ccan/compiler/test/compile_fail-printf.c
index 8f34ae5a1255b25f89aa0ae3424c9c47ef750cee..7664f65d4803a6426781e84493476ce72773c049 100644 (file)
--- a/ccan/compiler/test/compile_fail-printf.c
+++ b/ccan/compiler/test/compile_fail-printf.c
@@ -2,9 +2,11 @@
 
 static void PRINTF_FMT(2,3) my_printf(int x, const char *fmt, ...)
 {
+       (void)x;
+       (void)fmt;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned int i = 0;
 

diff --git a/ccan/compiler/test/run-is_compile_constant.c b/ccan/compiler/test/run-is_compile_constant.c
index a66f2e13e6c9c3749ae9357cb800517377d5863c..c914c68300868e79ee3c0b2862487740e76d6a1d 100644 (file)
--- a/ccan/compiler/test/run-is_compile_constant.c
+++ b/ccan/compiler/test/run-is_compile_constant.c
@@ -3,6 +3,8 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
+       (void)argv;
        plan_tests(2);
 
        ok1(!IS_COMPILE_CONSTANT(argc));

diff --git a/ccan/container_of/_info b/ccan/container_of/_info
index d50094bc68ec1ef077182028c0d045923160562f..b1160522edd4fcfd52935d39227d3d19653149ec 100644 (file)
--- a/ccan/container_of/_info
+++ b/ccan/container_of/_info
@@ -26,17 +26,19 @@
  *             struct timer timer;
  *     };
  *
- *     static void register_timer(struct timer *timer)
- *     {
- *             //...
- *     }
- *
  *     static void my_timer_callback(struct timer *timer)
  *     {
  *             struct info *info = container_of(timer, struct info, timer);
  *             printf("my_stuff is %u\n", info->my_stuff);
  *     }
  *
+ *     static void register_timer(struct timer *timer)
+ *     {
+ *             (void)timer;
+ *             (void)my_timer_callback;
+ *             //...
+ *     }
+ *
  *     int main(void)
  *     {
  *             struct info info = { .my_stuff = 1 };

diff --git a/ccan/container_of/test/compile_fail-bad-type.c b/ccan/container_of/test/compile_fail-bad-type.c
index b7a1459386b2d53c8f650388073f7e40f1934897..55a911a1b006c770ab703483e6b53775a851a4cb 100644 (file)
--- a/ccan/container_of/test/compile_fail-bad-type.c
+++ b/ccan/container_of/test/compile_fail-bad-type.c
@@ -6,7 +6,7 @@ struct foo {
        char b;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct foo foo = { .a = 1, .b = 2 };
        int *intp = &foo.a;

diff --git a/ccan/container_of/test/compile_fail-types.c b/ccan/container_of/test/compile_fail-types.c
index cae1c7abd20a1ed36ae6072faa8b50d9aea2644e..fbb97a9ee4f9db1df8f39b063086e18df3eb3994 100644 (file)
--- a/ccan/container_of/test/compile_fail-types.c
+++ b/ccan/container_of/test/compile_fail-types.c
@@ -6,7 +6,7 @@ struct foo {
        char b;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct foo foo = { .a = 1, .b = 2 }, *foop;
        int *intp = &foo.a;

diff --git a/ccan/container_of/test/compile_fail-var-types.c b/ccan/container_of/test/compile_fail-var-types.c
index f254d9210207fabfd3eedc69062516b0ccafc64e..ecdd90916fa64a49ddd899b67f3c5b222186d9a8 100644 (file)
--- a/ccan/container_of/test/compile_fail-var-types.c
+++ b/ccan/container_of/test/compile_fail-var-types.c
@@ -6,7 +6,7 @@ struct foo {
        char b;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct foo foo = { .a = 1, .b = 2 }, *foop;
        int *intp = &foo.a;

diff --git a/ccan/container_of/test/run.c b/ccan/container_of/test/run.c
index 18207f60521f418d75df8cee15293c062acc1a21..32557295ddec1d471e89873b1534bc4b5d2232b7 100644 (file)
--- a/ccan/container_of/test/run.c
+++ b/ccan/container_of/test/run.c
@@ -6,7 +6,7 @@ struct foo {
        char b;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct foo foo = { .a = 1, .b = 2 };
        int *intp = &foo.a;

diff --git a/ccan/cpuid/cpuid.c b/ccan/cpuid/cpuid.c
index 9a42d83e948d715232a1440f7f20271ca18a5ae7..4510def85b2dc0cb87fb0c780615a70da87fdd60 100644 (file)
--- a/ccan/cpuid/cpuid.c
+++ b/ccan/cpuid/cpuid.c
@@ -237,7 +237,7 @@ cputype_t cpuid_get_cpu_type(void)
                uint32_t i;
 
                get_cpuid(CPUID_VENDORID, &i, &u.bufu32[0], &u.bufu32[2], &u.bufu32[1]);
-               for (i = 0; i < sizeof(c_cpunames) / sizeof(c_cpunames); ++i) {
+               for (i = 0; i < sizeof(c_cpunames) / sizeof(c_cpunames[0]); ++i) {
                        if (strncmp(c_cpunames[i], u.buf, 12) == 0) {
                                cputype = (cputype_t)i;
                                break;

diff --git a/ccan/crypto/siphash24/siphash24.c b/ccan/crypto/siphash24/siphash24.c
index d250de3295418f6f5e127167d0fad0421d13bc87..20daa74d32b71fd8c296295a8ed9fba69d4c7d5e 100644 (file)
--- a/ccan/crypto/siphash24/siphash24.c
+++ b/ccan/crypto/siphash24/siphash24.c
@@ -45,6 +45,7 @@ static void check_siphash24(struct siphash24_ctx *ctx)
 static bool alignment_ok(const void *p, size_t n)
 {
 #if HAVE_UNALIGNED_ACCESS
+       (void)p; (void)n;
        return true;
 #else
        return ((size_t)p % n == 0);

diff --git a/ccan/endian/test/run.c b/ccan/endian/test/run.c
index a00fce74e456c42ce8ad9120418ad807967a4020..9bf47f13a6d6348937fc17f3103702c8a31c9802 100644 (file)
--- a/ccan/endian/test/run.c
+++ b/ccan/endian/test/run.c
@@ -3,7 +3,7 @@
 #include <stddef.h>
 #include <ccan/tap/tap.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        union {
                uint64_t u64;

diff --git a/ccan/err/test/run.c b/ccan/err/test/run.c
index 242e93f8061c246e344a26079f0b0fd2808bb813..aeaa3750b3d40ac7cc0223f24e4ae7fb4b0da42a 100644 (file)
--- a/ccan/err/test/run.c
+++ b/ccan/err/test/run.c
@@ -15,6 +15,7 @@ int main(int argc, char *argv[])
        int pfd[2];
        const char *base;
 
+       (void)argc;
        plan_tests(24);
 
        err_set_progname(argv[0]);
@@ -27,7 +28,8 @@ int main(int argc, char *argv[])
                base = argv[0];
 
        /* Test err() in child */
-       pipe(pfd);
+       if (pipe(pfd))
+               abort();
        fflush(stdout);
        if (fork()) {
                char buffer[BUFFER_MAX+1];
@@ -59,7 +61,8 @@ int main(int argc, char *argv[])
        }
 
        /* Test errx() in child */
-       pipe(pfd);
+       if (pipe(pfd))
+               abort();
        fflush(stdout);
        if (fork()) {
                char buffer[BUFFER_MAX+1];
@@ -89,7 +92,8 @@ int main(int argc, char *argv[])
 
 
        /* Test warn() in child */
-       pipe(pfd);
+       if (pipe(pfd))
+               abort();
        fflush(stdout);
        if (fork()) {
                char buffer[BUFFER_MAX+1];
@@ -121,7 +125,8 @@ int main(int argc, char *argv[])
        }
 
        /* Test warnx() in child */
-       pipe(pfd);
+       if (pipe(pfd))
+               abort();
        fflush(stdout);
        if (fork()) {
                char buffer[BUFFER_MAX+1];

diff --git a/ccan/foreach/test/run-nested.c b/ccan/foreach/test/run-nested.c
index aa20437ec443e643f275502e31d70d544ffeec20..0bb21c980057d29af5ac34680a15ca1cbf39f83d 100644 (file)
--- a/ccan/foreach/test/run-nested.c
+++ b/ccan/foreach/test/run-nested.c
@@ -44,7 +44,7 @@ static int count_iters(void)
 
 int main(void)
 {
-       int i, j, sum, max_iters;
+       int i, j, sum, max_iters = 0 /* keep gcc happy */;
        const char *istr, *jstr;
 
        plan_tests(13);

diff --git a/ccan/htable/_info b/ccan/htable/_info
index 7e06c3867a3f977797720e54368f25cb3084d6c6..a3bb76db6bf0395562bfbc96c02e0f9e98e04391 100644 (file)
--- a/ccan/htable/_info
+++ b/ccan/htable/_info
@@ -36,6 +36,7 @@
  *     // Wrapper for rehash function pointer.
  *     static size_t rehash(const void *e, void *unused)
  *     {
+ *             (void)unused;
  *             return hash_string(((struct name_to_digit *)e)->name);
  *     }
  *
@@ -64,7 +65,7 @@
  *     int main(int argc, char *argv[])
  *     {
  *             struct htable ht;
- *             unsigned int i;
+ *             int i;
  *             unsigned long val;
  *
  *             if (argc < 2)
@@ -73,7 +74,7 @@
  *
  *             // Create and populate hash table.
  *             htable_init(&ht, rehash, NULL);
- *             for (i = 0; i < sizeof(map)/sizeof(map[0]); i++)
+ *             for (i = 0; i < (int)(sizeof(map)/sizeof(map[0])); i++)
  *                     htable_add(&ht, hash_string(map[i].name), &map[i]);
  *
  *             // Add any aliases to the hash table.

diff --git a/ccan/htable/htable.h b/ccan/htable/htable.h
index 61ed9170fda461779840f63db55295757a9bce8a..9845388e1b9f47b7938e765a4682c7b4aee689fe 100644 (file)
--- a/ccan/htable/htable.h
+++ b/ccan/htable/htable.h
@@ -35,6 +35,7 @@ struct htable {
  *     // For simplicity's sake, say hash value is contents of elem.
  *     static size_t rehash(const void *elem, void *unused)
  *     {
+ *             (void)unused;
  *             return *(size_t *)elem;
  *     }
  *     static struct htable ht = HTABLE_INITIALIZER(ht, rehash, NULL);

diff --git a/ccan/htable/test/run-copy.c b/ccan/htable/test/run-copy.c
index 02d5bbe46856daef1689c784152bee6c218ea806..d111495ad4c775c20a6875e141aef19c12f942da 100644 (file)
--- a/ccan/htable/test/run-copy.c
+++ b/ccan/htable/test/run-copy.c
@@ -6,7 +6,7 @@
 
 #define NUM_VALS 512
 
-static size_t hash(const void *elem, void *unused)
+static size_t hash(const void *elem, void *unused UNNEEDED)
 {
        size_t h = *(uint64_t *)elem / 2;
        return h;
@@ -17,7 +17,7 @@ static bool cmp(const void *candidate, void *ptr)
        return *(const uint64_t *)candidate == *(const uint64_t *)ptr;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct htable ht, ht2;
        uint64_t val[NUM_VALS], i;

diff --git a/ccan/htable/test/run-size.c b/ccan/htable/test/run-size.c
index c92401c3c67d0d1d525c33f33f58d055512ee35f..1a2f5cdd1ef8cbbfc1ab84f8221b5bb61b9734ab 100644 (file)
--- a/ccan/htable/test/run-size.c
+++ b/ccan/htable/test/run-size.c
@@ -8,13 +8,13 @@
 
 /* We use the number divided by two as the hash (for lots of
    collisions). */
-static size_t hash(const void *elem, void *unused)
+static size_t hash(const void *elem, void *unused UNNEEDED)
 {
        size_t h = *(uint64_t *)elem / 2;
        return h;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct htable ht;
        uint64_t val[NUM_VALS];

diff --git a/ccan/htable/test/run-type-int.c b/ccan/htable/test/run-type-int.c
index 66346d0c70ab24eebcccb13af6f84587ca2c4399..7b71815f3c38fef390a63ad4e420040939338c0e 100644 (file)
--- a/ccan/htable/test/run-type-int.c
+++ b/ccan/htable/test/run-type-int.c
@@ -88,7 +88,7 @@ static void del_vals(struct htable_obj *ht,
 }
 
 static void del_vals_bykey(struct htable_obj *ht,
-                          const struct obj val[], unsigned int num)
+                          const struct obj val[] UNNEEDED, unsigned int num)
 {
        unsigned int i;
 
@@ -112,7 +112,7 @@ static bool check_mask(struct htable *ht, const struct obj val[], unsigned num)
        return true;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned int i;
        struct htable_obj ht, ht2;

diff --git a/ccan/htable/test/run-type.c b/ccan/htable/test/run-type.c
index e1a78f49616eee40d421994253b30b1c07a5aba7..a3616a5a37b8fb1f2588d9d8e369136c6436665e 100644 (file)
--- a/ccan/htable/test/run-type.c
+++ b/ccan/htable/test/run-type.c
@@ -83,7 +83,7 @@ static void del_vals(struct htable_obj *ht,
 }
 
 static void del_vals_bykey(struct htable_obj *ht,
-                          const struct obj val[], unsigned int num)
+                          const struct obj val[] UNNEEDED, unsigned int num)
 {
        unsigned int i;
 
@@ -107,7 +107,7 @@ static bool check_mask(struct htable *ht, const struct obj val[], unsigned num)
        return true;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned int i;
        struct htable_obj ht, ht2;

diff --git a/ccan/htable/test/run-zero-hash-first-entry.c b/ccan/htable/test/run-zero-hash-first-entry.c
index fdd18569e7cc516f2d5b7fb5bbc25a7d0a35bacf..3a1a939e8ab390b921c02a3a1607ca98a6c38389 100644 (file)
--- a/ccan/htable/test/run-zero-hash-first-entry.c
+++ b/ccan/htable/test/run-zero-hash-first-entry.c
@@ -8,7 +8,7 @@ struct data {
 };
 
 /* Hash is simply key itself. */
-static size_t hash(const void *e, void *unused)
+static size_t hash(const void *e, void *unused UNNEEDED)
 {
        struct data *d = (struct data *)e;
 

diff --git a/ccan/htable/test/run.c b/ccan/htable/test/run.c
index 09cde890f7ea34af2e8be9c080ebd472c2b8f21c..46514c7202f2438b54b15aca2f9c0800ca5f5dd4 100644 (file)
--- a/ccan/htable/test/run.c
+++ b/ccan/htable/test/run.c
@@ -10,7 +10,7 @@
 /* We use the number divided by two as the hash (for lots of
    collisions), plus set all the higher bits so we can detect if they
    don't get masked out. */
-static size_t hash(const void *elem, void *unused)
+static size_t hash(const void *elem, void *unused UNNEEDED)
 {
        size_t h = *(uint64_t *)elem / 2;
        h |= -1UL << NUM_BITS;
@@ -95,7 +95,7 @@ static bool check_mask(struct htable *ht, uint64_t val[], unsigned num)
        return true;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned int i, weight;
        uintptr_t perfect_bit;

diff --git a/ccan/ilog/test/run-out-of-line.c b/ccan/ilog/test/run-out-of-line.c
index 48205d380edd72c7e7ffbd67c8ef8cc0591f51fc..a0918d751c0ba4998f0873d1d3dffb3cdc7252d6 100644 (file)
--- a/ccan/ilog/test/run-out-of-line.c
+++ b/ccan/ilog/test/run-out-of-line.c
@@ -19,7 +19,7 @@ static int test_ilog64(uint64_t _v){
 
 #define NTRIALS (64)
 
-int main(int _argc,const char *_argv[]){
+int main(void){
   int i;
   int j;
   int (*il32)(uint32_t) = ilog32;

diff --git a/ccan/ilog/test/run.c b/ccan/ilog/test/run.c
index bda59f920a33e115958eeff8b91a6a6a8d2eb966..00824ac3a7b6d29f0a2e5c87442c31f145318905 100644 (file)
--- a/ccan/ilog/test/run.c
+++ b/ccan/ilog/test/run.c
@@ -19,7 +19,7 @@ static int test_ilog64(uint64_t _v){
 
 #define NTRIALS (64)
 
-int main(int _argc,const char *_argv[]){
+int main(void){
   int i;
   int j;
   /*This is how many tests you plan to run.*/

diff --git a/ccan/io/io.h b/ccan/io/io.h
index 9316dd180a9895adc2f60fdb6cdaeff6d77deb4a..e24beec4666a37284b72f545c735989119381ce5 100644 (file)
--- a/ccan/io/io.h
+++ b/ccan/io/io.h
@@ -47,7 +47,8 @@ struct io_conn;
  *     int fd[2];
  *     struct io_conn *conn;
  *
- *     pipe(fd);
+ *     if (pipe(fd) != 0)
+ *             exit(1);
  *     conn = io_new_conn(NULL, fd[0], conn_init, (const char *)"hi!");
  *     if (!conn)
  *             exit(1);
@@ -653,11 +654,11 @@ int io_conn_fd(const struct io_conn *conn);
  * io_time_override - override the normal call for time.
  * @nowfn: the function to call.
  *
- * io usually uses time_now() internally, but this forces it
+ * io usually uses time_mono() internally, but this forces it
  * to use your function (eg. for debugging).  Returns the old
  * one.
  */
-struct timeabs (*io_time_override(struct timeabs (*now)(void)))(void);
+struct timemono (*io_time_override(struct timemono (*now)(void)))(void);
 
 /**
  * io_set_debug - set synchronous mode on a connection.

diff --git a/ccan/io/poll.c b/ccan/io/poll.c
index cddc3cacd266e5b80392d91af367d689da093bd6..36af33ef0854de3323c8f29c4dc522c976091764 100644 (file)
--- a/ccan/io/poll.c
+++ b/ccan/io/poll.c
@@ -16,11 +16,11 @@ static struct pollfd *pollfds = NULL;
 static struct fd **fds = NULL;
 static LIST_HEAD(closing);
 static LIST_HEAD(always);
-static struct timeabs (*nowfn)(void) = time_now;
+static struct timemono (*nowfn)(void) = time_mono;
 
-struct timeabs (*io_time_override(struct timeabs (*now)(void)))(void)
+struct timemono (*io_time_override(struct timemono (*now)(void)))(void)
 {
-       struct timeabs (*old)(void) = nowfn;
+       struct timemono (*old)(void) = nowfn;
        nowfn = now;
        return old;
 }
@@ -262,7 +262,7 @@ void *io_loop(struct timers *timers, struct timer **expired)
                assert(num_waiting);
 
                if (timers) {
-                       struct timeabs now, first;
+                       struct timemono now, first;
 
                        now = nowfn();
 
@@ -274,7 +274,7 @@ void *io_loop(struct timers *timers, struct timer **expired)
                        /* Now figure out how long to wait for the next one. */
                        if (timer_earliest(timers, &first)) {
                                uint64_t next;
-                               next = time_to_msec(time_between(first, now));
+                               next = time_to_msec(timemono_between(first, now));
                                if (next < INT_MAX)
                                        ms_timeout = next;
                                else

diff --git a/ccan/io/test/run-01-start-finish.c b/ccan/io/test/run-01-start-finish.c
index eb12e9488aea2eaca1dc445fb1cff6c46bddbbfc..04952db88e5ce9e3d65c9cadb57fee5e4730e001 100644 (file)
--- a/ccan/io/test/run-01-start-finish.c
+++ b/ccan/io/test/run-01-start-finish.c
@@ -69,7 +69,7 @@ static int make_listen_fd(const char *port, struct addrinfo **info)
 int main(void)
 {
        int state = 0;
-       struct addrinfo *addrinfo;
+       struct addrinfo *addrinfo = NULL;
        struct io_listener *l;
        int fd;
 

diff --git a/ccan/io/test/run-02-read.c b/ccan/io/test/run-02-read.c
index e25bbbb49cc5ee8e4ad4af8856e36e62608a751e..74cb2f021d87393c1dd0110a10a110ad1d52f09a 100644 (file)
--- a/ccan/io/test/run-02-read.c
+++ b/ccan/io/test/run-02-read.c
@@ -71,7 +71,7 @@ static int make_listen_fd(const char *port, struct addrinfo **info)
 int main(void)
 {
        struct data *d = malloc(sizeof(*d));
-       struct addrinfo *addrinfo;
+       struct addrinfo *addrinfo = NULL;
        struct io_listener *l;
        int fd, status;
 

diff --git a/ccan/io/test/run-15-timeout.c b/ccan/io/test/run-15-timeout.c
index 5709ddaa8a25416d6bb56c2a7d21ce81688e0e52..a4ab23add0abed3b0a3bcc5d536983db458ce8b5 100644 (file)
--- a/ccan/io/test/run-15-timeout.c
+++ b/ccan/io/test/run-15-timeout.c
@@ -47,8 +47,7 @@ static struct io_plan *init_conn(struct io_conn *conn, struct data *d)
        d->conn = conn;
        io_set_finish(conn, finish_ok, d);
 
-       timer_add(&d->timers, &d->timer,
-                 timeabs_add(time_now(), time_from_usec(d->timeout_usec)));
+       timer_addrel(&d->timers, &d->timer, time_from_usec(d->timeout_usec));
 
        return io_read(conn, d->buf, sizeof(d->buf), no_timeout, d);
 }
@@ -97,7 +96,7 @@ int main(void)
        plan_tests(21);
        d->state = 0;
        d->timeout_usec = 100000;
-       timers_init(&d->timers, time_now());
+       timers_init(&d->timers, time_mono());
        timer_init(&d->timer);
        fd = make_listen_fd(PORT, &addrinfo);
        ok1(fd >= 0);
@@ -131,7 +130,7 @@ int main(void)
 
        /* One element, d->timer. */
        ok1(expired == &d->timer);
-       ok1(!timers_expire(&d->timers, time_now()));
+       ok1(!timers_expire(&d->timers, time_mono()));
        ok1(d->state == 1);
 
        io_close(d->conn);

diff --git a/ccan/io/test/run-20-io_time_override.c b/ccan/io/test/run-20-io_time_override.c
index bf493c9912cf3ff2dd00033b3adfd8d09f434e34..c0b607a74cfdf09cb6a6c703da40b0ae794fc3bd 100644 (file)
--- a/ccan/io/test/run-20-io_time_override.c
+++ b/ccan/io/test/run-20-io_time_override.c
@@ -45,9 +45,9 @@ static int make_listen_fd(const char *port, struct addrinfo **info)
        return fd;
 }
 
-static struct timeabs fake_time;
+static struct timemono fake_time;
 
-static struct timeabs get_fake_time(void)
+static struct timemono get_fake_time(void)
 {
        return fake_time;
 }
@@ -63,12 +63,12 @@ int main(void)
        /* This is how many tests you plan to run */
        plan_tests(7);
 
-       fake_time = time_now();
+       fake_time = time_mono();
 
        timers_init(&timers, fake_time);
        timer_init(&timer);
-       timer_add(&timers, &timer,
-                 timeabs_add(fake_time, time_from_sec(1000)));
+       timer_addmono(&timers, &timer,
+                     timemono_add(fake_time, time_from_sec(1000)));
 
        fd = make_listen_fd(PORT, &addrinfo);
        freeaddrinfo(addrinfo);
@@ -77,12 +77,12 @@ int main(void)
        ok1(l);
 
        fake_time.ts.tv_sec += 1000;
-       ok1(io_time_override(get_fake_time) == time_now);
+       ok1(io_time_override(get_fake_time) == time_mono);
        ok1(io_loop(&timers, &expired) == NULL);
 
        ok1(expired == &timer);
        ok1(!timers_expire(&timers, fake_time));
-       ok1(io_time_override(time_now) == get_fake_time);
+       ok1(io_time_override(time_mono) == get_fake_time);
        io_close_listener(l);
 
        timers_cleanup(&timers);

diff --git a/ccan/isaac/test/run.c b/ccan/isaac/test/run.c
index 81a46bc2ce8fc245469b8ba90ef897052b852b53..c7ea4f97a38c6d7068b979156fce0d6f8fd2455b 100644 (file)
--- a/ccan/isaac/test/run.c
+++ b/ccan/isaac/test/run.c
@@ -134,7 +134,7 @@ static const uint32_t STATEVEC[ISAAC_SZ<<1]={
   0x46D95CA5, 0xC54CD95B, 0x9D855E89, 0x4BB5AF29
 };
 
-int main(int _argc,const char *_argv[]){
+int main(void){
   isaac_ctx   isaac;
   int         i;
   int         j;

diff --git a/ccan/isaac/test/run64.c b/ccan/isaac/test/run64.c
index db2b4d350e5b5d61eb5fed8e95615f0eaf416ee3..de9bef492bbc80c656caa36c888861c965f99094 100644 (file)
--- a/ccan/isaac/test/run64.c
+++ b/ccan/isaac/test/run64.c
@@ -262,7 +262,7 @@ static const uint64_t STATEVEC64[ISAAC64_SZ<<1]={
   0x1877B51E57A764D5ULL, 0x001F837CC7350524ULL
 };
 
-int main(int _argc,const char *_argv[]){
+int main(void){
   isaac64_ctx isaac64;
   int         i;
   int         j;

diff --git a/ccan/jmap/tools/Makefile b/ccan/jmap/tools/Makefile
index b9f07b9803a9b596bbbc9710504ceb976e9adf3f..efb46698a96c7f2d1c1a51fed48af0ab948bd079 100644 (file)
--- a/ccan/jmap/tools/Makefile
+++ b/ccan/jmap/tools/Makefile
@@ -1,6 +1,6 @@
 CFLAGS=-Wall -Werror -O3 -I../../..
-LDFLAGS=-lJudy
+LDLIBS=-lJudy
 
 speed: speed.o
 
-speed.o: speed.c ../jmap.h ../jmap_type.h ../jmap.c
+speed.o: speed.c ../jmap.h

diff --git a/ccan/jmap/tools/speed.c b/ccan/jmap/tools/speed.c
index d2ecd6f67694d84674d148c667b69a637d655c6b..6cd6d4799c14516ba539155bb5b81958560f2e7e 100644 (file)
--- a/ccan/jmap/tools/speed.c
+++ b/ccan/jmap/tools/speed.c
@@ -1,38 +1,33 @@
 /* Simple speed tests for jmap. */
-#include <ccan/jmap/jmap_type.h>
 #include <ccan/jmap/jmap.c>
+#include <ccan/time/time.c>
 #include <stdio.h>
 #include <stdlib.h>
-#include <time.h>
 #include <unistd.h>
-#include <sys/time.h>
 
 struct object {
        /* Some contents. Doubles as consistency check. */
        struct object *self;
 };
 
+struct jmap_obj {
+       JMAP_MEMBERS(unsigned int, struct object *);
+};
+
 /* Nanoseconds per operation */
-static size_t normalize(const struct timeval *start,
-                       const struct timeval *stop,
+static size_t normalize(const struct timeabs *start,
+                       const struct timeabs *stop,
                        unsigned int num)
 {
-       struct timeval diff;
-
-       timersub(stop, start, &diff);
-
-       /* Floating point is more accurate here. */
-       return (double)(diff.tv_sec * 1000000 + diff.tv_usec)
-               / num * 1000;
+       return time_to_nsec(time_divide(time_between(*stop, *start), num));
 }
 
-JMAP_DEFINE_UINTIDX_TYPE(struct object, obj);
-
 int main(int argc, char *argv[])
 {
        struct object *objs;
-       size_t i, j, num;
-       struct timeval start, stop;
+       unsigned int i, j;
+       size_t num;
+       struct timeabs start, stop;
        struct jmap_obj *jmap;
 
        num = argv[1] ? atoi(argv[1]) : 1000000;
@@ -42,110 +37,110 @@ int main(int argc, char *argv[])
                objs[i].self = &objs[i];
        }
 
-       jmap = jmap_obj_new();
+       jmap = jmap_new(struct jmap_obj);
 
        printf("Initial insert: ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               jmap_obj_add(jmap, i, objs[i].self);
-       gettimeofday(&stop, NULL);
+               jmap_add(jmap, i, objs[i].self);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Initial lookup (match): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               if (jmap_obj_get(jmap, i)->self != objs[i].self)
+               if (jmap_get(jmap, i)->self != objs[i].self)
                        abort();
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Initial lookup (miss): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               if (jmap_obj_get(jmap, i+num))
+               if (jmap_get(jmap, i+num))
                        abort();
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        /* Lookups in order are very cache-friendly for judy; try random */
        printf("Initial lookup (random): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0, j = 0; i < num; i++, j = (j + 10007) % num)
-               if (jmap_obj_get(jmap, j)->self != &objs[j])
+               if (jmap_get(jmap, j)->self != &objs[j])
                        abort();
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Initial delete all: ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               jmap_obj_del(jmap, i);
-       gettimeofday(&stop, NULL);
+               jmap_del(jmap, i);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Initial re-inserting: ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               jmap_obj_add(jmap, i, objs[i].self);
-       gettimeofday(&stop, NULL);
+               jmap_add(jmap, i, objs[i].self);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Deleting first half: ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i+=2)
-               jmap_obj_del(jmap, i);
-       gettimeofday(&stop, NULL);
+               jmap_del(jmap, i);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Adding (a different) half: ");
        fflush(stdout);
 
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i+=2)
-               jmap_obj_add(jmap, num+i, objs[i].self);
-       gettimeofday(&stop, NULL);
+               jmap_add(jmap, num+i, objs[i].self);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Lookup after half-change (match): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 1; i < num; i+=2)
-               if (jmap_obj_get(jmap, i)->self != objs[i].self)
+               if (jmap_get(jmap, i)->self != objs[i].self)
                        abort();
        for (i = 0; i < num; i+=2)
-               if (jmap_obj_get(jmap, i+num)->self != objs[i].self)
+               if (jmap_get(jmap, i+num)->self != objs[i].self)
                        abort();
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Lookup after half-change(miss): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               if (jmap_obj_get(jmap, i+num*2))
+               if (jmap_get(jmap, i+num*2))
                        abort();
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        /* Hashtables with delete markers can fill with markers over time.
         * so do some changes to see how it operates in long-term. */
        printf("Details: churning first time\n");
        for (i = 1; i < num; i+=2) {
-               if (!jmap_obj_del(jmap, i))
+               if (!jmap_del(jmap, i))
                        abort();
-               jmap_obj_add(jmap, i, objs[i].self);
+               jmap_add(jmap, i, objs[i].self);
        }
        for (i = 0; i < num; i+=2) {
-               if (!jmap_obj_del(jmap, i+num))
+               if (!jmap_del(jmap, i+num))
                        abort();
-               jmap_obj_add(jmap, i, objs[i].self);
+               jmap_add(jmap, i, objs[i].self);
        }
        for (i = 1; i < 5; i++) {
                printf("Churning %s time: ",
@@ -154,84 +149,88 @@ int main(int argc, char *argv[])
                       : i == 3 ? "fourth"
                       : "fifth");
                fflush(stdout);
-               gettimeofday(&start, NULL);
+
+               start = time_now();
                for (j = 0; j < num; j++) {
-                       if (!jmap_obj_del(jmap, num*(i-1)+j))
+                       if (!jmap_del(jmap, num*(i-1)+j))
                                abort();
-                       jmap_obj_add(jmap, num*i+j, &objs[j]);
+                       jmap_add(jmap, num*i+j, &objs[j]);
                }
-               gettimeofday(&stop, NULL);
+               stop = time_now();
                printf(" %zu ns\n", normalize(&start, &stop, num));
        }
 
        /* Spread out the keys more to try to make it harder. */
        printf("Details: reinserting with spread\n");
        for (i = 0; i < num; i++) {
-               if (!jmap_obj_del(jmap, num*4 + i))
+               if (!jmap_del(jmap, num*4 + i))
                        abort();
-               jmap_obj_add(jmap, num * 5 + i * 9, objs[i].self);
+               jmap_add(jmap, num * 5 + i * 9, objs[i].self);
        }
 
-       if (jmap_obj_popcount(jmap, 0, -1) != num)
+       if (jmap_popcount(jmap, 0, -1) != num)
                abort();
 
        printf("Lookup after churn & spread (match): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               if (jmap_obj_get(jmap, num * 5 + i * 9)->self != objs[i].self) {
+               if (jmap_get(jmap, num * 5 + i * 9)->self != objs[i].self) {
                        printf("i  =%u\n", i);
                        abort();
                }
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Lookup after churn & spread (miss): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i++)
-               if (jmap_obj_get(jmap, num * 6 + i * 9))
+               if (jmap_get(jmap, num * 6 + i * 9))
                        abort();
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Lookup after churn & spread (random): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0, j = 0; i < num; i++, j = (j + 10007) % num)
-               if (jmap_obj_get(jmap, num * 5 + j * 9)->self != &objs[j])
+               if (jmap_get(jmap, num * 5 + j * 9)->self != &objs[j])
                        abort();
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Lookup after churn & spread (half-random): ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0, j = 0; i < num/2; i++, j = (j + 10007) % num) {
-               if (jmap_obj_get(jmap, num * 5 + j * 9)->self != &objs[j])
+               if (jmap_get(jmap, num * 5 + j * 9)->self != &objs[j])
                        abort();
-               if (jmap_obj_get(jmap, num * 5 + (j + 1) * 9)->self != &objs[j+1])
+               if (jmap_get(jmap, num * 5 + (j + 1) * 9)->self != &objs[j+1])
                        abort();
        }
-       gettimeofday(&stop, NULL);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Deleting half after churn & spread: ");
        fflush(stdout);
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i+=2)
-               jmap_obj_del(jmap, num * 5 + i * 9);
-       gettimeofday(&stop, NULL);
+               jmap_del(jmap, num * 5 + i * 9);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
        printf("Adding (a different) half after churn & spread: ");
        fflush(stdout);
 
-       gettimeofday(&start, NULL);
+       start = time_now();
        for (i = 0; i < num; i+=2)
-               jmap_obj_add(jmap, num * 6 + i * 9, objs[i].self);
-       gettimeofday(&stop, NULL);
+               jmap_add(jmap, num * 6 + i * 9, objs[i].self);
+       stop = time_now();
        printf(" %zu ns\n", normalize(&start, &stop, num));
 
+       jmap_free(jmap);
+       free (objs);
+
        return 0;
 }

diff --git a/ccan/likely/test/run-debug.c b/ccan/likely/test/run-debug.c
index 83f22afab2bf622141ebb4330af9c88e9de96c4f..72015ee42858301bd343572fead21ae9cce81a2b 100644 (file)
--- a/ccan/likely/test/run-debug.c
+++ b/ccan/likely/test/run-debug.c
@@ -26,7 +26,7 @@ static bool likely_one_unlikely_two(unsigned int val1, unsigned int val2)
        return false;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *bad;
 

diff --git a/ccan/likely/test/run.c b/ccan/likely/test/run.c
index fa1dc9f6eade527431deae6b2d1b1ec470630357..28ea798578e7f4558acbe1aeafaccdc3fafc1ea5 100644 (file)
--- a/ccan/likely/test/run.c
+++ b/ccan/likely/test/run.c
@@ -17,7 +17,7 @@ static bool one_seems_unlikely(unsigned int val)
        return false;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        plan_tests(4);
 

diff --git a/ccan/list/_info b/ccan/list/_info
index 60790a9903f084eb0492436a95dd097eefe67416..c4f3e2a0acf21b32097cf5b3a9194361831d0a4b 100644 (file)
--- a/ccan/list/_info
+++ b/ccan/list/_info
@@ -31,7 +31,7 @@
  *     {
  *             struct parent p;
  *             struct child *c;
- *             unsigned int i;
+ *             int i;
  *
  *             if (argc < 2)
  *                     errx(1, "Usage: %s parent children...", argv[0]);

diff --git a/ccan/list/list.h b/ccan/list/list.h
index 0800a0fa144f20f1ab0985b5b3dd369fe9f39eef..a6b00385984c52ce9ab3a614e351437616f69b8e 100644 (file)
--- a/ccan/list/list.h
+++ b/ccan/list/list.h
@@ -291,6 +291,21 @@ static inline bool list_empty_nodebug(const struct list_head *h)
 }
 #endif
 
+/**
+ * list_empty_nocheck - is a list empty?
+ * @h: the list_head
+ *
+ * If the list is empty, returns true. This doesn't perform any
+ * debug check for list consistency, so it can be called without
+ * locks, racing with the list being modified. This is ok for
+ * checks where an incorrect result is not an issue (optimized
+ * bail out path for example).
+ */
+static inline bool list_empty_nocheck(const struct list_head *h)
+{
+       return h->n.next == &h->n;
+}
+
 /**
  * list_del - delete an entry from an (unknown) linked list.
  * @n: the list_node to delete from the list.
@@ -701,12 +716,12 @@ static inline void list_prepend_list_(struct list_head *to,
  * so you can break and continue as normal.
  *
  * WARNING! Being the low-level macro that it is, this wrapper doesn't know
- * nor care about the type of @i. The only assumtion made is that @i points
+ * nor care about the type of @i. The only assumption made is that @i points
  * to a chunk of memory that at some @offset, relative to @i, contains a
- * properly filled `struct node_list' which in turn contains pointers to
- * memory chunks and it's turtles all the way down. Whith all that in mind
+ * properly filled `struct list_node' which in turn contains pointers to
+ * memory chunks and it's turtles all the way down. With all that in mind
  * remember that given the wrong pointer/offset couple this macro will
- * happilly churn all you memory untill SEGFAULT stops it, in other words
+ * happily churn all you memory until SEGFAULT stops it, in other words
  * caveat emptor.
  *
  * It is worth mentioning that one of legitimate use-cases for that wrapper

diff --git a/ccan/list/test/run-CCAN_LIST_DEBUG.c b/ccan/list/test/run-CCAN_LIST_DEBUG.c
index 9fcb1d7456a699720f6e9d141039a411aa092a19..b8e5165a6441c841ef77d85798ef5547d49ef65b 100644 (file)
--- a/ccan/list/test/run-CCAN_LIST_DEBUG.c
+++ b/ccan/list/test/run-CCAN_LIST_DEBUG.c
@@ -17,6 +17,7 @@ static int my_fprintf(FILE *stream, const char *format, ...)
 {
        va_list ap;
        int ret;
+       (void)stream;
        va_start(ap, format);
        ret = vsprintf(printf_buffer, format, ap);
        va_end(ap);
@@ -28,7 +29,7 @@ static int my_fprintf(FILE *stream, const char *format, ...)
 #include <ccan/tap/tap.h>
 #include <ccan/list/list.c>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct list_head list;
        struct list_node n1;
@@ -44,7 +45,7 @@ int main(int argc, char *argv[])
        list.n.prev = &n1;
 
        /* Aborting version. */
-       sprintf(expect, "run-CCAN_LIST_DEBUG.c:50: prev corrupt in node %p (0) of %p\n",
+       sprintf(expect, "run-CCAN_LIST_DEBUG.c:51: prev corrupt in node %p (0) of %p\n",
                &list, &list);
        if (setjmp(aborted) == 0) {
                assert(list_empty(&list));

diff --git a/ccan/list/test/run-check-corrupt.c b/ccan/list/test/run-check-corrupt.c
index 5dd9f9cc835a91a7fc3f9448a3dad80fe407ec88..94c2e67e7bed36ddf3f19f511de8327c296ac1fa 100644 (file)
--- a/ccan/list/test/run-check-corrupt.c
+++ b/ccan/list/test/run-check-corrupt.c
@@ -16,6 +16,7 @@ static int my_fprintf(FILE *stream, const char *format, ...)
 {
        va_list ap;
        int ret;
+       (void)stream;
        va_start(ap, format);
        ret = vsprintf(printf_buffer, format, ap);
        va_end(ap);
@@ -26,7 +27,7 @@ static int my_fprintf(FILE *stream, const char *format, ...)
 #include <ccan/tap/tap.h>
 #include <ccan/list/list.c>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct list_head list;
        struct list_node n1;

diff --git a/ccan/list/test/run-check-nonconst.c b/ccan/list/test/run-check-nonconst.c
index b006a8a2e260963f63983ce51075dcb7ab642880..d3cb652a34a5be0469571af9c7ed0d667fb7549c 100644 (file)
--- a/ccan/list/test/run-check-nonconst.c
+++ b/ccan/list/test/run-check-nonconst.c
@@ -8,7 +8,7 @@ struct child {
        struct list_node list;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct child c1, c2;
        struct list_head list = LIST_HEAD_INIT(list);

diff --git a/ccan/list/test/run-list_del_from-assert.c b/ccan/list/test/run-list_del_from-assert.c
index 05d6cad62c4b54517ab068043f9fe30fd0f9bae5..9404b7120ee9d4e3cbe587fe6ed456cbf1db3f87 100644 (file)
--- a/ccan/list/test/run-list_del_from-assert.c
+++ b/ccan/list/test/run-list_del_from-assert.c
@@ -7,7 +7,7 @@
 #include <unistd.h>
 #include <signal.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct list_head list1, list2;
        struct list_node n1, n2, n3;

diff --git a/ccan/list/test/run-list_prev-list_next.c b/ccan/list/test/run-list_prev-list_next.c
index b496f11f84d8bea54191be4ff4069882be5aa3f9..cc61e03a01f3f160f2c94bb91b12bca23d60ba85 100644 (file)
--- a/ccan/list/test/run-list_prev-list_next.c
+++ b/ccan/list/test/run-list_prev-list_next.c
@@ -14,7 +14,7 @@ struct child {
        struct list_node list;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct parent parent;
        struct child c1, c2, c3;

diff --git a/ccan/list/test/run-prepend_list.c b/ccan/list/test/run-prepend_list.c
index d382f5a83a4ea60add31ed834285b7e51a3b2b29..fecd4196fd702d2ff42dd17f2bc188595c9e56a2 100644 (file)
--- a/ccan/list/test/run-prepend_list.c
+++ b/ccan/list/test/run-prepend_list.c
@@ -17,7 +17,7 @@ static bool list_expect(struct list_head *h, ...)
        return (n->next == &h->n);
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct list_head h1, h2;
        struct list_node n[4];

diff --git a/ccan/list/test/run-single-eval.c b/ccan/list/test/run-single-eval.c
index f90eed357ac9875d2cca6bc031612aca4d307160..db0bffdda5aa30092fb4ef2bc6a8601a34695042 100644 (file)
--- a/ccan/list/test/run-single-eval.c
+++ b/ccan/list/test/run-single-eval.c
@@ -19,7 +19,7 @@ static LIST_HEAD(static_list);
 
 #define ref(obj, counter) ((counter)++, (obj))
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct parent parent;
        struct child c1, c2, c3, *c, *n;

diff --git a/ccan/list/test/run.c b/ccan/list/test/run.c
index 7616af6c6095e8ca0978d35608ba56a2846e7b73..5787e4563e08f8de08c095a992f257df75d98c64 100644 (file)
--- a/ccan/list/test/run.c
+++ b/ccan/list/test/run.c
@@ -16,7 +16,7 @@ struct child {
 
 static LIST_HEAD(static_list);
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct parent parent;
        struct child c1, c2, c3, x1, *c, *n;

diff --git a/ccan/mem/mem.h b/ccan/mem/mem.h
index f2c3d5c7a6f795e2e091df8a545992c6533b50ec..19f69c038c67efe1e11ac8ab5cec036123aa3b95 100644 (file)
--- a/ccan/mem/mem.h
+++ b/ccan/mem/mem.h
@@ -250,6 +250,7 @@ static inline void *memcheck_(const void *data, size_t len)
 #else
 static inline void *memcheck_(const void *data, size_t len)
 {
+       (void)len;
        return (void *)data;
 }
 #endif

diff --git a/ccan/noerr/_info b/ccan/noerr/_info
index 082c71e601e451cf77ef022555d25d102f054de2..85f1f6f9c3906496969eba2b234fe11146b92749 100644 (file)
--- a/ccan/noerr/_info
+++ b/ccan/noerr/_info
@@ -37,7 +37,7 @@
  *                     return false;
  *             }
  *             // A short write means out of space.
- *             if (ret < strlen(string)) {
+ *             if (ret < (int)strlen(string)) {
  *                     unlink(file);
  *                     errno = ENOSPC;
  *                     return false;

diff --git a/ccan/noerr/test/run.c b/ccan/noerr/test/run.c
index 48086a24d542e98dccaa33548748850f5d464b83..31fb67400572d43aca0abf7b36f003ecf225346f 100644 (file)
--- a/ccan/noerr/test/run.c
+++ b/ccan/noerr/test/run.c
@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <assert.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        const char *name = "noerr.file";
        int fd;

diff --git a/ccan/opt/opt.h b/ccan/opt/opt.h
index 690907e595eff6922690204eb4c76a6be3e59d8c..0d508cf6fd173d1578bf26d1a703c3b12bbf3643 100644 (file)
--- a/ccan/opt/opt.h
+++ b/ccan/opt/opt.h
@@ -185,7 +185,7 @@ void opt_register_table(const struct opt_table *table, const char *desc);
  * string (or see opt_set_alloc) and return false.
  *
  * Example:
- * static char *explode(const char *optarg, void *unused)
+ * static char *explode(const char *optarg, void *unused UNNEEDED)
  * {
  *     errx(1, "BOOM! %s", optarg);
  * }

diff --git a/ccan/opt/test/compile_ok-const-arg.c b/ccan/opt/test/compile_ok-const-arg.c
index f1d10da10601d43e6dc07990d8db68920e8d892f..a73443473bf8707cbb71f190f2e66feec7fd0431 100644 (file)
--- a/ccan/opt/test/compile_ok-const-arg.c
+++ b/ccan/opt/test/compile_ok-const-arg.c
@@ -4,7 +4,7 @@
 #include <ccan/opt/parse.c>
 #include <ccan/opt/usage.c>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        opt_register_noarg("-v", opt_version_and_exit,
                           (const char *)"1.2.3",

diff --git a/ccan/opt/test/run-add_desc.c b/ccan/opt/test/run-add_desc.c
index ded3f88061deddcaa5d1a8378a659631f9af614f..b559c7f747689bae70d34589ee9794f4cf710ac0 100644 (file)
--- a/ccan/opt/test/run-add_desc.c
+++ b/ccan/opt/test/run-add_desc.c
@@ -4,19 +4,19 @@
 #include <ccan/opt/helpers.c>
 #include <ccan/opt/parse.c>
 
-static void show_10(char buf[OPT_SHOW_LEN], const void *arg)
+static void show_10(char buf[OPT_SHOW_LEN], const void *arg UNNEEDED)
 {
        memset(buf, 'X', 10);
        buf[10] = '\0';
 }
 
-static void show_max(char buf[OPT_SHOW_LEN], const void *arg)
+static void show_max(char buf[OPT_SHOW_LEN], const void *arg UNNEEDED)
 {
        memset(buf, 'X', OPT_SHOW_LEN);
 }
 
 /* Test add_desc helper. */
-int main(int argc, char *argv[])
+int main(void)
 {
        struct opt_table opt;
        char *ret;

diff --git a/ccan/opt/test/run-checkopt.c b/ccan/opt/test/run-checkopt.c
index d54a75205e9c675c9adc9312372809cbefa00964..8447f98d1a829254f01a4417688545238f1d6f8b 100644 (file)
--- a/ccan/opt/test/run-checkopt.c
+++ b/ccan/opt/test/run-checkopt.c
@@ -53,7 +53,7 @@ static void reset(void)
        opt_count = opt_num_short = opt_num_short_arg = opt_num_long = 0;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        int exitval;
 

diff --git a/ccan/opt/test/run-consume_words.c b/ccan/opt/test/run-consume_words.c
index 9f164656abd602d0b4fe414664bb51c498a62553..c1eaf56aa2678fc972671861a100f233c665a22f 100644 (file)
--- a/ccan/opt/test/run-consume_words.c
+++ b/ccan/opt/test/run-consume_words.c
@@ -5,7 +5,7 @@
 #include <ccan/opt/parse.c>
 
 /* Test consume_words helper. */
-int main(int argc, char *argv[])
+int main(void)
 {
        size_t prefix, len;
        bool start = true;

diff --git a/ccan/opt/test/run-helpers.c b/ccan/opt/test/run-helpers.c
index 6ec17f589fdb76d8c1fc7f0f78d39619d18c6294..0a08a85f7aa3930011cba5600186f3a21d5c5f09 100644 (file)
--- a/ccan/opt/test/run-helpers.c
+++ b/ccan/opt/test/run-helpers.c
@@ -52,7 +52,7 @@ static int saved_printf(const char *fmt, ...)
        return ret;
 }
 
-static int saved_fprintf(FILE *ignored, const char *fmt, ...)
+static int saved_fprintf(FILE *ignored UNNEEDED, const char *fmt, ...)
 {
        va_list ap;
        int ret;

diff --git a/ccan/opt/test/run-iter.c b/ccan/opt/test/run-iter.c
index e6b13dadea8d33b38d02e55ca99c20e0d956d1d8..d34fd6dc176a844f166d0fb32f9450f7bcd0a9f7 100644 (file)
--- a/ccan/opt/test/run-iter.c
+++ b/ccan/opt/test/run-iter.c
@@ -10,7 +10,7 @@
 #include <ccan/opt/parse.c>
 
 /* Test iterators. */
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned j, i, len = 0;
        const char *p;

diff --git a/ccan/opt/test/run-set_alloc.c b/ccan/opt/test/run-set_alloc.c
index 6a10d5979fca77d9e024fca95e962108ad66dbe4..1dbb351bedf41b0022a8abd26b3c0fbbc07ad445 100644 (file)
--- a/ccan/opt/test/run-set_alloc.c
+++ b/ccan/opt/test/run-set_alloc.c
@@ -2,15 +2,15 @@
 #include <stdlib.h>
 
 /* Make sure we override these! */
-static void *no_malloc(size_t size)
+static void *no_malloc(size_t size UNNEEDED)
 {
        abort();
 }
-static void *no_realloc(void *p, size_t size)
+static void *no_realloc(void *p UNNEEDED, size_t size UNNEEDED)
 {
        abort();
 }
-static void no_free(void *p)
+static void no_free(void *p UNNEEDED)
 {
        abort();
 }

diff --git a/ccan/opt/test/run-usage.c b/ccan/opt/test/run-usage.c
index aec8324474f2b2a547574d870968c92b476e3e3e..cea678f3806ded21d7636bf3f3380ebe67e3ca02 100644 (file)
--- a/ccan/opt/test/run-usage.c
+++ b/ccan/opt/test/run-usage.c
@@ -6,7 +6,7 @@
 #include "utils.h"
 
 /* Ensure width is sane. */
-static const char *getenv_override(const char *name)
+static const char *getenv_override(const char *name UNNEEDED)
 {
        return "100";
 }
@@ -18,13 +18,13 @@ static const char *getenv_override(const char *name)
 #include <ccan/opt/helpers.c>
 #include <ccan/opt/parse.c>
 
-static char *my_cb(void *p)
+static char *my_cb(void *p UNNEEDED)
 {
        return NULL;
 }
 
 /* Test helpers. */
-int main(int argc, char *argv[])
+int main(void)
 {
        char *output;
        char *longname = strdup("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

diff --git a/ccan/opt/test/utils.c b/ccan/opt/test/utils.c
index c2967fca173d51010b810fcaa626eb6ebff420df..a9bedf2e0063333060a597a3bd591ff76744ab00 100644 (file)
--- a/ccan/opt/test/utils.c
+++ b/ccan/opt/test/utils.c
@@ -8,7 +8,7 @@
 #include "utils.h"
 
 unsigned int test_cb_called;
-char *test_noarg(void *arg)
+char *test_noarg(void *arg UNNEEDED)
 {
        test_cb_called++;
        return NULL;

diff --git a/ccan/order/order.c b/ccan/order/order.c
index 863a8e16e1425803621ee0bc68e37ee376693f20..5ff85a987fec66fd5c55aa89d3a18ba5bcd9020c 100644 (file)
--- a/ccan/order/order.c
+++ b/ccan/order/order.c
@@ -24,7 +24,7 @@
                           const _type *b,                              \
                           void *ctx)                                   \
        {                                                               \
-               return _order_##_oname(a, b, int2ptr(0));               \
+               (void)ctx; return _order_##_oname(a, b, int2ptr(0));    \
        }                                                               \
        int _order_##_oname##_reverse(const void *a,                    \
                                      const void *b,                    \
@@ -36,6 +36,7 @@
                                     const _type *b,                    \
                                     void *ctx)                         \
        {                                                               \
+               (void)ctx;                                              \
                return _order_##_oname##_reverse(a, b, int2ptr(0));     \
        }                                                               \
        int order_##_oname##_noctx(const void *a,                       \

diff --git a/ccan/order/test/compile_fail_1.c b/ccan/order/test/compile_fail_1.c
index ba63ca1ef605fd315f81948b6c5cdf7e95c18a55..3eed7aa6484b0cd372e728f3f868f80b878bc4c9 100644 (file)
--- a/ccan/order/test/compile_fail_1.c
+++ b/ccan/order/test/compile_fail_1.c
@@ -12,7 +12,7 @@ typedef int item_t;
 typedef struct item item_t;
 #endif
 
-int main(int argc, char *argv[])
+int main(void)
 {
        total_order_cb(cb0, struct item, struct cmp_info *) = fancy_cmp;
        _total_order_cb cb1 = total_order_cast(fancy_cmp,

diff --git a/ccan/order/test/compile_fail_2.c b/ccan/order/test/compile_fail_2.c
index 5a7126d87703c9291e885cf20562f7d766c7b5ff..595ffcbbab62c466239bb35e077a06a2fa9a3637 100644 (file)
--- a/ccan/order/test/compile_fail_2.c
+++ b/ccan/order/test/compile_fail_2.c
@@ -12,7 +12,7 @@ typedef int ctx_t;
 typedef struct cmp_info ctx_t;
 #endif
 
-int main(int argc, char *argv[])
+int main(void)
 {
        total_order_cb(cb0, struct item, struct cmp_info *) = fancy_cmp;
        _total_order_cb cb1 = total_order_cast(fancy_cmp, struct item,

diff --git a/ccan/order/test/compile_ok.c b/ccan/order/test/compile_ok.c
index 33a420422d14a77a48c42062541ec45afe548393..37cc4e4ea0cea49ec25641fc99c34f0528ba7d5b 100644 (file)
--- a/ccan/order/test/compile_ok.c
+++ b/ccan/order/test/compile_ok.c
@@ -6,7 +6,7 @@
 
 #include "fancy_cmp.h"
 
-int main(int argc, char *argv[])
+int main(void)
 {
        total_order_cb(cb0, struct item, struct cmp_info *) = fancy_cmp;
        _total_order_cb cb1 = total_order_cast(fancy_cmp,

diff --git a/ccan/order/test/run-fancy.c b/ccan/order/test/run-fancy.c
index be5ff3f2d53d8a303247dee7a087d3be8d2c6861..5a287c4cbcfc76013d7be533afab547b521c7132 100644 (file)
--- a/ccan/order/test/run-fancy.c
+++ b/ccan/order/test/run-fancy.c
@@ -8,7 +8,7 @@
 
 #include "fancy_cmp.h"
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct item item1 = {
                .value = 0,

diff --git a/ccan/pipecmd/_info b/ccan/pipecmd/_info
index 4621d72fc3b94d78192a8eb33fb9bec60309a600..a560bfea05ccc4e53807dde67d0546c48b6f0246 100644 (file)
--- a/ccan/pipecmd/_info
+++ b/ccan/pipecmd/_info
@@ -28,7 +28,8 @@
  *     char input[12];
  *
  *     if (argc == 2) {
- *             write(STDOUT_FILENO, "hello world\n", 12);
+ *             if (write(STDOUT_FILENO, "hello world\n", 12) != 12)
+ *                     exit(1);
  *             exit(0);
  *     }
  *     child = pipecmd(&outputfd, NULL, NULL, argv[0], "ignoredarg", NULL);

diff --git a/ccan/pipecmd/pipecmd.c b/ccan/pipecmd/pipecmd.c
index e8aec15b4e7f62993489de618a445439ac06c8c7..32772a83bc7b69c96cff57747aa779771f2e7604 100644 (file)
--- a/ccan/pipecmd/pipecmd.c
+++ b/ccan/pipecmd/pipecmd.c
@@ -122,7 +122,10 @@ pid_t pipecmdarr(int *fd_fromchild, int *fd_tochild, int *fd_errfromchild,
 
        child_errno_fail:
                err = errno;
-               write(execfail[1], &err, sizeof(err));
+               /* Gcc's warn-unused-result fail. */
+               if (write(execfail[1], &err, sizeof(err))) {
+                       ;
+               }
                exit(127);
        }
 

diff --git a/ccan/ptr_valid/ptr_valid.c b/ccan/ptr_valid/ptr_valid.c
index ef95d34f39c7a145a2b0c3621c8c764ea65d140b..dc61dd27cbc1fbd46a06e73ad25d4c1bb6fb9848 100644 (file)
--- a/ccan/ptr_valid/ptr_valid.c
+++ b/ccan/ptr_valid/ptr_valid.c
@@ -246,9 +246,14 @@ static bool check_with_child(struct ptr_valid_batch *batch,
                        return false;
        }
 
-       write(batch->to_child, &p, sizeof(p));
-       write(batch->to_child, &size, sizeof(size));
-       write(batch->to_child, &is_write, sizeof(is_write));
+       if (write(batch->to_child, &p, sizeof(p))
+           + write(batch->to_child, &size, sizeof(size))
+           + write(batch->to_child, &is_write, sizeof(is_write))
+           != sizeof(p) + sizeof(size) + sizeof(is_write)) {
+               finish_child(batch);
+               errno = EFAULT;
+               return false;
+       }
 
        if (read(batch->from_child, &ret, sizeof(ret)) != sizeof(ret)) {
                finish_child(batch);

diff --git a/ccan/ptrint/_info b/ccan/ptrint/_info
index 6300a9bca9e5ed04c7f96c396654db257bd8e096..30170da92bf2f23b888e4e74b1aaf25d4d4dfdf0 100644 (file)
--- a/ccan/ptrint/_info
+++ b/ccan/ptrint/_info
@@ -29,7 +29,7 @@
  *
  *     void (*cb)(void *opaque) = callback;
  *
- *     int main(int argc, char *argv[])
+ *     int main(void)
  *     {
  *             int val = 17;
  *

diff --git a/ccan/read_write_all/_info b/ccan/read_write_all/_info
index 20c5e8454fd3b00be4a84acb5714dc178ba927a3..0210dff9bf51cc98e84f9f29e7ddadd80f6d95cb 100644 (file)
--- a/ccan/read_write_all/_info
+++ b/ccan/read_write_all/_info
@@ -17,7 +17,7 @@
  *     #include <ccan/read_write_all/read_write_all.h>
  *
  *     #define BUFFER_SIZE 10
- *     int main(int argc, char *argv[])
+ *     int main(void)
  *     {
  *             char buffer[BUFFER_SIZE+1];
  *

diff --git a/ccan/read_write_all/test/run-read_all.c b/ccan/read_write_all/test/run-read_all.c
index 29f81fc703e05f0b930a2a4136b7981dfc7aaa06..6e6588d4149a79351f04993bbc37470ab8d36626 100644 (file)
--- a/ccan/read_write_all/test/run-read_all.c
+++ b/ccan/read_write_all/test/run-read_all.c
@@ -17,6 +17,7 @@ static int p2c[2], c2p[2];
 static void got_signal(int sig)
 {
        char c = 0;
+       (void)sig;
        if (write(p2c[1], &c, 1) == 1)
                sigcount++;
 }
@@ -24,7 +25,7 @@ static void got_signal(int sig)
 /* < PIPE_BUF *will* be atomic.  But > PIPE_BUF only *might* be non-atomic. */
 #define BUFSZ (1024*1024)
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *buffer;
        char c = 0;

diff --git a/ccan/read_write_all/test/run-write_all.c b/ccan/read_write_all/test/run-write_all.c
index e2baf48dfe79893a9729b749516ebcdd3704c61e..c789d6b7829b3b05243ce7ae9d6bd679cfc8735f 100644 (file)
--- a/ccan/read_write_all/test/run-write_all.c
+++ b/ccan/read_write_all/test/run-write_all.c
@@ -19,6 +19,9 @@ static ssize_t write_return;
 
 static ssize_t test_write(int fd, const void *buf, size_t count)
 {
+       (void)fd;
+       (void)buf;
+
        if (write_return == 0) {
                errno = ENOSPC;
                return 0;
@@ -39,7 +42,7 @@ static ssize_t test_write(int fd, const void *buf, size_t count)
 
 #define BUFSZ 1024
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *buffer;
 

diff --git a/ccan/str/_info b/ccan/str/_info
index 251d999a83f47328ead2ca8720d9859f59f43d03..b579525faac18e1fa52096b2e9b6eff34a70b404 100644 (file)
--- a/ccan/str/_info
+++ b/ccan/str/_info
@@ -26,11 +26,11 @@
  *
  *     int main(int argc, char *argv[])
  *     {
- *             if (argv[1] && streq(argv[1], "--verbose"))
+ *             if (argc > 1 && streq(argv[1], "--verbose"))
  *                     printf("verbose set\n");
- *             if (argv[1] && strstarts(argv[1], "--"))
+ *             if (argc > 1 && strstarts(argv[1], "--"))
  *                     printf("Some option set\n");
- *             if (argv[1] && strends(argv[1], "cow-powers"))
+ *             if (argc > 1 && strends(argv[1], "cow-powers"))
  *                     printf("Magic option set\n");
  *             return 0;
  *     }

diff --git a/ccan/str/test/compile_fail-STR_MAX_CHARS.c b/ccan/str/test/compile_fail-STR_MAX_CHARS.c
index 74448c1b81af19024612331de56e3c4ff30b220a..8e0fd2e2f65216ffa750bdecc9d9f9e87894df7c 100644 (file)
--- a/ccan/str/test/compile_fail-STR_MAX_CHARS.c
+++ b/ccan/str/test/compile_fail-STR_MAX_CHARS.c
@@ -4,7 +4,7 @@ struct s {
        int val;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct s
 #ifdef FAIL

diff --git a/ccan/str/test/compile_fail-isalnum.c b/ccan/str/test/compile_fail-isalnum.c
index 930defffa0c231862679e42ddb851655cf5a93a1..5d9895822ccd96442a7b1391d87d558856f13cca 100644 (file)
--- a/ccan/str/test/compile_fail-isalnum.c
+++ b/ccan/str/test/compile_fail-isalnum.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isalnum.

diff --git a/ccan/str/test/compile_fail-isalpha.c b/ccan/str/test/compile_fail-isalpha.c
index 2005109829be36e1ea558e287b770d9fbb1cc663..33d365538aff0a28c6f5b7f36119363ab6d7ae71 100644 (file)
--- a/ccan/str/test/compile_fail-isalpha.c
+++ b/ccan/str/test/compile_fail-isalpha.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isalpha.

diff --git a/ccan/str/test/compile_fail-isascii.c b/ccan/str/test/compile_fail-isascii.c
index ee55e4997434c5cd4c11c01a0bd45d28af67d37d..3946e0b3b88a288606903756c53eaaf6d267d0e8 100644 (file)
--- a/ccan/str/test/compile_fail-isascii.c
+++ b/ccan/str/test/compile_fail-isascii.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isascii.

diff --git a/ccan/str/test/compile_fail-isblank.c b/ccan/str/test/compile_fail-isblank.c
index f4cb961d740d9dd0bc9b99825a3af51d3d50d848..e14b0d7e66ac1a8e0018233c709b7274e182a468 100644 (file)
--- a/ccan/str/test/compile_fail-isblank.c
+++ b/ccan/str/test/compile_fail-isblank.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF || !HAVE_ISBLANK
 #error We need typeof to check isblank.

diff --git a/ccan/str/test/compile_fail-iscntrl.c b/ccan/str/test/compile_fail-iscntrl.c
index bc74146542f1b36ecefe1fb394bfb84254d4b571..f9abf1dc56e4d4464dd417b2c2586769a22ccf15 100644 (file)
--- a/ccan/str/test/compile_fail-iscntrl.c
+++ b/ccan/str/test/compile_fail-iscntrl.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check iscntrl.

diff --git a/ccan/str/test/compile_fail-isdigit.c b/ccan/str/test/compile_fail-isdigit.c
index 71d1c714330f2cf9f363e46a3161a4e0f5c9e93c..a3ee439c631eb867a876c955169cb4be2119c03f 100644 (file)
--- a/ccan/str/test/compile_fail-isdigit.c
+++ b/ccan/str/test/compile_fail-isdigit.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isdigit.

diff --git a/ccan/str/test/compile_fail-islower.c b/ccan/str/test/compile_fail-islower.c
index ca3f9907e52087eefb75d6f40831f11c50b12e8e..8f5c456197ff33cb2e4fdeef9704702b2aefa43c 100644 (file)
--- a/ccan/str/test/compile_fail-islower.c
+++ b/ccan/str/test/compile_fail-islower.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check islower.

diff --git a/ccan/str/test/compile_fail-isprint.c b/ccan/str/test/compile_fail-isprint.c
index 6432e41d2b7db9db5ddc0ecd35611fcc169e49d3..85ed028f60f1e99a4da8983e3f3df4800e5e88ad 100644 (file)
--- a/ccan/str/test/compile_fail-isprint.c
+++ b/ccan/str/test/compile_fail-isprint.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isprint.

diff --git a/ccan/str/test/compile_fail-ispunct.c b/ccan/str/test/compile_fail-ispunct.c
index 5d941fcba687a23863780acc6076479ba05bfcd8..09d4279a9344d4770d93eb9b689ea2639c344ab1 100644 (file)
--- a/ccan/str/test/compile_fail-ispunct.c
+++ b/ccan/str/test/compile_fail-ispunct.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check ispunct.

diff --git a/ccan/str/test/compile_fail-isspace.c b/ccan/str/test/compile_fail-isspace.c
index bfee1f89f166614b603b9aec5c2315ad430a3af0..798cfcd470f82db076a0b37ff79375baad194344 100644 (file)
--- a/ccan/str/test/compile_fail-isspace.c
+++ b/ccan/str/test/compile_fail-isspace.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isspace.

diff --git a/ccan/str/test/compile_fail-isupper.c b/ccan/str/test/compile_fail-isupper.c
index 4cf9fd35785c37e40e1ea16529845886896381f8..56f5dee11b9512268bdc782d85069b8f10331fcd 100644 (file)
--- a/ccan/str/test/compile_fail-isupper.c
+++ b/ccan/str/test/compile_fail-isupper.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isupper.

diff --git a/ccan/str/test/compile_fail-isxdigit.c b/ccan/str/test/compile_fail-isxdigit.c
index 65e6006a885b029ae7cec620a44aebd652567e22..ea4d5269add225115a436092fc8184e3a45151a0 100644 (file)
--- a/ccan/str/test/compile_fail-isxdigit.c
+++ b/ccan/str/test/compile_fail-isxdigit.c
@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+       (void)argc;
 #ifdef FAIL
 #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF
 #error We need typeof to check isxdigit.

diff --git a/ccan/str/test/compile_fail-strchr.c b/ccan/str/test/compile_fail-strchr.c
index 74a7314d06b7807eb22c1f3865ac9586c7b83d0d..bdaf034abd1f3e0403ecc55a96458672908a5cc7 100644 (file)
--- a/ccan/str/test/compile_fail-strchr.c
+++ b/ccan/str/test/compile_fail-strchr.c
@@ -1,7 +1,7 @@
 #define CCAN_STR_DEBUG 1
 #include <ccan/str/str.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
 #if !HAVE_TYPEOF

diff --git a/ccan/str/test/compile_fail-strrchr.c b/ccan/str/test/compile_fail-strrchr.c
index ba7d17e031985df303e0f23a85f1421bf4024578..57fba0ed58d152e640f27d2c40e912c765572271 100644 (file)
--- a/ccan/str/test/compile_fail-strrchr.c
+++ b/ccan/str/test/compile_fail-strrchr.c
@@ -1,7 +1,7 @@
 #define CCAN_STR_DEBUG 1
 #include <ccan/str/str.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
 #if !HAVE_TYPEOF

diff --git a/ccan/str/test/compile_fail-strstr.c b/ccan/str/test/compile_fail-strstr.c
index deefef6542bd3bef6bee74b0bd5ba7309288f03c..7bd8ac22f13b83911971f747661fd08e40cdcfdf 100644 (file)
--- a/ccan/str/test/compile_fail-strstr.c
+++ b/ccan/str/test/compile_fail-strstr.c
@@ -1,7 +1,7 @@
 #define CCAN_STR_DEBUG 1
 #include <ccan/str/str.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
 #if !HAVE_TYPEOF

diff --git a/ccan/str/test/run-STR_MAX_CHARS.c b/ccan/str/test/run-STR_MAX_CHARS.c
index ae6969c7b07c63bcfd7c7c4c83972398f25f8680..fa45bad8a6414bd7df108823e3b2adeecbb864dd 100644 (file)
--- a/ccan/str/test/run-STR_MAX_CHARS.c
+++ b/ccan/str/test/run-STR_MAX_CHARS.c
@@ -4,7 +4,7 @@
 #include <ccan/tap/tap.h>
 #include <stdint.h>
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char str[1000];
        struct {

diff --git a/ccan/str/test/run.c b/ccan/str/test/run.c
index 0f00ea320d2a67fbc8c65448f14017abbdb1a165..9917fe7111c5bac1ff34ba52b61854e4f7862a66 100644 (file)
--- a/ccan/str/test/run.c
+++ b/ccan/str/test/run.c
@@ -21,7 +21,7 @@ static char *strdup_rev(const char *s)
        return ret;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        unsigned int i, j, n;
        char *strings[NUM_SUBSTRINGS * NUM_SUBSTRINGS];

diff --git a/ccan/strmap/_info b/ccan/strmap/_info
index c128cc27b5c3cbe941cd5e72a4bef2ae2c043f91..eba8fe444ae78e1119e03644ab0f55d29d1d4d23 100644 (file)
--- a/ccan/strmap/_info
+++ b/ccan/strmap/_info
@@ -16,10 +16,11 @@
  *     license_depends_compat FAIL
  *
  * Example:
+ * #include <ccan/compiler/compiler.h>
  * #include <ccan/strmap/strmap.h>
  * #include <stdio.h>
  *
- * static bool dump(const char *member, size_t value, void *unused)
+ * static bool dump(const char *member, size_t value, void *unused UNNEEDED)
  * {
  *     printf("%s at %zu. ", member, value);
  *     // true means keep going with iteration.
@@ -32,7 +33,7 @@
  *     STRMAP(size_t) map;
  *
  *     strmap_init(&map);
- *     for (i = 1; i < argc; i++)
+ *     for (i = 1; i < (size_t)argc; i++)
  *             // This only adds the first time for this arg.
  *             strmap_add(&map, argv[i], i);
  *

diff --git a/ccan/strmap/test/run-iterate-const.c b/ccan/strmap/test/run-iterate-const.c
index 63bea95236af32ba1372c460151243bf3f5d7d66..dfd9dca73847db6e100dc2716d80b9b5b191469e 100644 (file)
--- a/ccan/strmap/test/run-iterate-const.c
+++ b/ccan/strmap/test/run-iterate-const.c
@@ -5,7 +5,7 @@
 static bool found = false;
 
 /* Make sure const args work. */
-static bool find_string(const char *str, char *member, const char *cmp)
+static bool find_string(const char *str UNNEEDED, char *member, const char *cmp)
 {
        if (strcmp(member, cmp) == 0)
                found = true;

diff --git a/ccan/strmap/test/run-prefix.c b/ccan/strmap/test/run-prefix.c
index d88eb55655c2bfe3737ca3fc510f8d3b43658bc9..6232d71b26135106016d22a01f84feee45c988ca 100644 (file)
--- a/ccan/strmap/test/run-prefix.c
+++ b/ccan/strmap/test/run-prefix.c
@@ -15,7 +15,7 @@ static bool in_order(const char *index, char *value, unsigned int *count)
        return true;
 }
 
-static bool find_empty(const char *index, char *value, char *empty)
+static bool find_empty(const char *index, char *value UNNEEDED, char *empty)
 {
        if (index == empty)
                pass("Found empty entry!");

diff --git a/ccan/take/_info b/ccan/take/_info
index 693824664802aebdeef970c4de29f23fb4fc0efb..fcb4f318a36ad77fdf1e7e8440de463b4f2d51cf 100644 (file)
--- a/ccan/take/_info
+++ b/ccan/take/_info
@@ -37,7 +37,7 @@
  *     {
  *             char *b;
  *
- *             if (argv[1]) // Mangle in place.
+ *             if (argc > 1) // Mangle in place.
  *                     b = base(take(argv[1]));
  *             else
  *                     b = base("test/string");

diff --git a/ccan/take/test/run.c b/ccan/take/test/run.c
index 0c8ca2a1d6ae5207e76fabb249f2737327c5595b..ba170fb3aad71261f59bc7cd71a7b6feb65b69b6 100644 (file)
--- a/ccan/take/test/run.c
+++ b/ccan/take/test/run.c
@@ -15,7 +15,7 @@ static void *my_realloc(void *p, size_t len)
 #include <ccan/tap/tap.h>
 
 static int my_allocfail_called;
-static void my_allocfail(const void *p)
+static void my_allocfail(const void *p UNNEEDED)
 {
        my_allocfail_called++;
 }      

diff --git a/ccan/tal/_info b/ccan/tal/_info
index 890cb2e767a638b346f90e8f5b6be76bd6db3b2c..5285c1632b403121a5e499efae30ab7eb7d561ef 100644 (file)
--- a/ccan/tal/_info
+++ b/ccan/tal/_info
@@ -29,7 +29,7 @@
  * Example:
  *     #include <stdio.h>
  *     #include <err.h>
- *     #include <ccan/talloc/talloc.h>
+ *     #include <ccan/tal/tal.h>
  *
  *     // A structure containing a popened command.
  *     struct command {

diff --git a/ccan/tal/grab_file/_info b/ccan/tal/grab_file/_info
index 68ad089b06f23d59e4ef318f0f107c76a9e50e87..056f10990b08111ce1ebdc6c66541c445d87c7d0 100644 (file)
--- a/ccan/tal/grab_file/_info
+++ b/ccan/tal/grab_file/_info
@@ -18,6 +18,8 @@
  *     {
  *             char *file;
  *
+ *             if (argc > 2)
+ *                     err(1, "Takes 0 or 1 arguments");
  *             file = grab_file(NULL, argv[1]);
  *             if (!file)
  *                     err(1, "Could not read file %s", argv[1]);

diff --git a/ccan/tal/grab_file/test/run-grab.c b/ccan/tal/grab_file/test/run-grab.c
index b258230e84b270b65b9669e58d5ff884a181a9a9..ddb5ca307a48e899fab560df273874ceab7e97b0 100644 (file)
--- a/ccan/tal/grab_file/test/run-grab.c
+++ b/ccan/tal/grab_file/test/run-grab.c
@@ -10,7 +10,7 @@
 #include <ccan/tal/str/str.h>
 
 int
-main(int argc, char *argv[])
+main(void)
 {
        unsigned int    i;
        char            **split, *str;

diff --git a/ccan/tal/link/_info b/ccan/tal/link/_info
index db2ad61454687f4f9ba3a4b885df4ff2e77f75cc..8e39e781d8569978517854646c21d87cdf2fa68a 100644 (file)
--- a/ccan/tal/link/_info
+++ b/ccan/tal/link/_info
@@ -87,7 +87,7 @@
  *
  *     int main(int argc, char *argv[])
  *     {
- *             unsigned int i;
+ *             int i;
  *             const char **values;
  *
  *             // Initialize cache.

diff --git a/ccan/tal/link/link.c b/ccan/tal/link/link.c
index c25d97e581c9ab7b2a5580835a682532a1401f24..7c8892d2b59fc882167d3b0b8a0a5a80f7d0c5c2 100644 (file)
--- a/ccan/tal/link/link.c
+++ b/ccan/tal/link/link.c
@@ -15,7 +15,7 @@ struct link {
 
 static void linkable_notifier(tal_t *linkable,
                              enum tal_notify_type type,
-                             void *info)
+                             void *info UNNEEDED)
 {
        struct linkable *l = tal_parent(linkable);
        assert(type == TAL_NOTIFY_STEAL || type == TAL_NOTIFY_FREE);

diff --git a/ccan/tal/link/test/run.c b/ccan/tal/link/test/run.c
index fdbb4f02e56dfa86f21b3e11020675a3718af8d6..e031fef2806d1d92faff4891b3b765b69880a3fc 100644 (file)
--- a/ccan/tal/link/test/run.c
+++ b/ccan/tal/link/test/run.c
@@ -4,12 +4,12 @@
 #include <err.h>
 
 static unsigned int destroy_count = 0;
-static void destroy_obj(void *obj)
+static void destroy_obj(void *obj UNNEEDED)
 {
        destroy_count++;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *linkable, *p1, *p2, *p3;
        void **voidpp;

diff --git a/ccan/tal/stack/_info b/ccan/tal/stack/_info
index 803a0058dc1358534731da56eae68bc82ffac240..b7de3dd065e77528bc8f2f37079efbb7bc47720e 100644 (file)
--- a/ccan/tal/stack/_info
+++ b/ccan/tal/stack/_info
@@ -38,7 +38,7 @@
  *             return retval;
  *     }
  *
- *     int main(int argc, char *argv[])
+ *     int main(void)
  *     {
  *             tal_t *tmp_ctx = tal_newframe();
  *             int *val = do_work();

diff --git a/ccan/tal/str/_info b/ccan/tal/str/_info
index cb81c9e19df33a64eb0e6323810d3d3129d9ff7e..3037cfde2fba99fcf1e817c0117ed8b89909fee3 100644 (file)
--- a/ccan/tal/str/_info
+++ b/ccan/tal/str/_info
@@ -20,6 +20,8 @@
  *             char *textfile;
  *             char **lines;
  *
+ *             if (argc > 2)
+ *                     errx(1, "Takes 0 or 1 arguments");
  *             // Grab lines in file.
  *             textfile = grab_file(NULL, argv[1]);
  *             if (!textfile)

diff --git a/ccan/tal/str/str.h b/ccan/tal/str/str.h
index 0c1821331e6a733b7a43fe3491e19b9065947eb8..5147ca2d4667fc7cc6997c34c9e6fdc5fc113c85 100644 (file)
--- a/ccan/tal/str/str.h
+++ b/ccan/tal/str/str.h
@@ -171,6 +171,7 @@ char *tal_strjoin(const void *ctx, char *strings[], const char *delim,
  *     {
  *             char *person, *input;
  *
+ *             (void)argc;
  *             // Join args and trim trailing space.
  *             input = tal_strjoin(NULL, argv+1, " ", STR_NO_TRAIL);
  *             if (tal_strreg(NULL, input,

diff --git a/ccan/tal/str/test/run-fmt-terminate.c b/ccan/tal/str/test/run-fmt-terminate.c
index 9dfd00155a536873da4a1c7b4ea93f6b67070309..374ca03a1fed893f017cc89c632c13d41a2507ed 100644 (file)
--- a/ccan/tal/str/test/run-fmt-terminate.c
+++ b/ccan/tal/str/test/run-fmt-terminate.c
@@ -6,7 +6,7 @@
 #include "helper.h"
 
 /* Empty format string: should still terminate! */
-int main(int argc, char *argv[])
+int main(void)
 {
        char *str;
        const char *fmt = "";

diff --git a/ccan/tal/str/test/run-strndup.c b/ccan/tal/str/test/run-strndup.c
index d967354842c2ef083543061612e5143ed7701c8a..55e35fd4be8c6fb1a8033a311d1ff4d8c17ff001 100644 (file)
--- a/ccan/tal/str/test/run-strndup.c
+++ b/ccan/tal/str/test/run-strndup.c
@@ -5,7 +5,7 @@
 #include <ccan/tap/tap.h>
 #include "helper.h"
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char *str, *copy;
 

diff --git a/ccan/tal/str/test/run-strreg.c b/ccan/tal/str/test/run-strreg.c
index fa8a86c66e6127872b1313644e343dc1d05860c2..93b8602a3c1f8ab067c4406ece439db949ae6b5b 100644 (file)
--- a/ccan/tal/str/test/run-strreg.c
+++ b/ccan/tal/str/test/run-strreg.c
@@ -14,7 +14,7 @@ static bool find_parent(tal_t *child, tal_t *parent)
        return false;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        void *ctx = tal_strdup(NULL, "toplevel");
        char *a, *b;

diff --git a/ccan/tal/str/test/run.c b/ccan/tal/str/test/run.c
index 4b9cf1fb5581e2a1596733f098f1bbc33e3540b0..a59d940087cfc81e5a39566a51cfb8790934cb03 100644 (file)
--- a/ccan/tal/str/test/run.c
+++ b/ccan/tal/str/test/run.c
@@ -10,7 +10,7 @@
 static const char *substrings[]
 = { "far", "bar", "baz", "b", "ba", "z", "ar", NULL };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char **split, *str;
        void *ctx;

diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c
index 79476772c585564b7e0840f215b59d09844723f1..842059d031b76977d665b31f1aedd3259a86ff0f 100644 (file)
--- a/ccan/tal/tal.c
+++ b/ccan/tal/tal.c
@@ -323,7 +323,7 @@ static struct name *add_name_property(struct tal_hdr *t, const char *name)
 }
 
 static struct children *add_child_property(struct tal_hdr *parent,
-                                          struct tal_hdr *child)
+                                          struct tal_hdr *child UNNEEDED)
 {
        struct children *prop = allocate(sizeof(*prop));
        if (prop) {

diff --git a/ccan/tal/test/run-allocfail.c b/ccan/tal/test/run-allocfail.c
index a166be3f6520a8795ea2c7bd916f0bfdf2a9cada..97cba9f6848d37d54594f666292bb82f21dbbce3 100644 (file)
--- a/ccan/tal/test/run-allocfail.c
+++ b/ccan/tal/test/run-allocfail.c
@@ -30,7 +30,7 @@ static void nofail_on_error(const char *msg)
        err_count++;
 }
 
-static void destroy_p(void *p)
+static void destroy_p(void *p UNNEEDED)
 {
 }
 

diff --git a/ccan/tal/test/run-destructor.c b/ccan/tal/test/run-destructor.c
index 873548889e91472013c3901b92bae8f01ae4e25c..7183f7c5b5a3daaff2e543d35e9f25c6d33366a2 100644 (file)
--- a/ccan/tal/test/run-destructor.c
+++ b/ccan/tal/test/run-destructor.c
@@ -24,7 +24,7 @@ static void destroy_child(char *p)
        destroy_count++;
 }
 
-static void destroy_inc(char *p)
+static void destroy_inc(char *p UNNEEDED)
 {
        destroy_count++;
 }

diff --git a/ccan/tal/test/run-free.c b/ccan/tal/test/run-free.c
index 29aa8c6f49dacf462300f41eda207b414c29ea95..f21264748d40a056a7e1ae5ed1d0976190d86e5a 100644 (file)
--- a/ccan/tal/test/run-free.c
+++ b/ccan/tal/test/run-free.c
@@ -2,7 +2,7 @@
 #include <ccan/tal/tal.c>
 #include <ccan/tap/tap.h>
 
-static void destroy_errno(char *p)
+static void destroy_errno(char *p UNNEEDED)
 {
        errno = ENOENT;
 }

diff --git a/ccan/tal/test/run-notifier.c b/ccan/tal/test/run-notifier.c
index b57c902e80ba9c3b7ec6a9ea285b4c0be0b40419..3820444f86f8245c38ffb9817f8d6cb38de506d1 100644 (file)
--- a/ccan/tal/test/run-notifier.c
+++ b/ccan/tal/test/run-notifier.c
@@ -20,7 +20,7 @@ static void *my_realloc(void *old, size_t size)
        return new;
 }
 
-static void notify1(char *p, enum tal_notify_type notify, void *info)
+static void notify1(char *p UNNEEDED, enum tal_notify_type notify, void *info)
 {
        ok1(ctx == ctx);
        ok1(notify == expect);
@@ -31,7 +31,9 @@ static void notify1(char *p, enum tal_notify_type notify, void *info)
        notified1++;
 }
 
-static void notify2(char *ctx, enum tal_notify_type notify, void *info)
+static void notify2(char *ctx UNNEEDED,
+                   enum tal_notify_type notify UNNEEDED,
+                   void *info UNNEEDED)
 {
        notified2++;
 }

diff --git a/ccan/tal/test/run-overflow.c b/ccan/tal/test/run-overflow.c
index d975398b4ba39b9e55ef35a57b18537aa514bbc8..d1919c1cceefcc65702fd5bf65a2ef015c30f7d7 100644 (file)
--- a/ccan/tal/test/run-overflow.c
+++ b/ccan/tal/test/run-overflow.c
@@ -4,7 +4,7 @@
 
 static int error_count;
 
-static void my_error(const char *msg)
+static void my_error(const char *msg UNNEEDED)
 {
        error_count++;
 }

diff --git a/ccan/tal/test/run-test-backend.c b/ccan/tal/test/run-test-backend.c
index 8fdfc064abb7eca68d06a18d0f4b00f7b9927df3..ebcd811192cfc9e2c39f09e9aff914ce25767ed0 100644 (file)
--- a/ccan/tal/test/run-test-backend.c
+++ b/ccan/tal/test/run-test-backend.c
@@ -31,7 +31,7 @@ static void *my_realloc(void *old, size_t new_size)
 
 #define NUM_ALLOCS 1000
 
-static void destroy_p(void *p)
+static void destroy_p(void *p UNNEEDED)
 {
 }
 

diff --git a/ccan/tcon/test/compile_fail-container1.c b/ccan/tcon/test/compile_fail-container1.c
index a67e2090766d3217d0665f815314bb6ccfcdb143..44645a7ec6d417875ceed8910915efea3a0d2193 100644 (file)
--- a/ccan/tcon/test/compile_fail-container1.c
+++ b/ccan/tcon/test/compile_fail-container1.c
@@ -22,7 +22,7 @@ struct info_tcon {
        TCON(TCON_CONTAINER(concan, struct outer, inner));
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct info_tcon info;
        struct outer ovar;

diff --git a/ccan/tcon/test/compile_fail-container1w.c b/ccan/tcon/test/compile_fail-container1w.c
index 0226b68e9f01b9095ce01a50dec0092360407c62..19ba5bdcc915d22851009a630b4bda32dd85f242 100644 (file)
--- a/ccan/tcon/test/compile_fail-container1w.c
+++ b/ccan/tcon/test/compile_fail-container1w.c
@@ -17,7 +17,7 @@ struct info_base {
        char *infop;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        TCON_WRAP(struct info_base,
                  TCON_CONTAINER(concan, struct outer, inner)) info;

diff --git a/ccan/tcon/test/compile_fail-container2.c b/ccan/tcon/test/compile_fail-container2.c
index 6cad734c5f57647568ff652e3e6b87488b6c7989..e41984d9f082e85b00ea60a6684ce25bd481f085 100644 (file)
--- a/ccan/tcon/test/compile_fail-container2.c
+++ b/ccan/tcon/test/compile_fail-container2.c
@@ -22,7 +22,7 @@ struct info_tcon {
        TCON(TCON_CONTAINER(concan, struct outer, inner));
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct info_tcon info;
        struct outer ovar;

diff --git a/ccan/tcon/test/compile_fail-container2w.c b/ccan/tcon/test/compile_fail-container2w.c
index c73123cacd2c8639e88cfda48591c515fb0f3276..3564ab0c480320c51bb810c36dedff76a8cf32b9 100644 (file)
--- a/ccan/tcon/test/compile_fail-container2w.c
+++ b/ccan/tcon/test/compile_fail-container2w.c
@@ -17,7 +17,7 @@ struct info_base {
        char *infop;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        TCON_WRAP(struct info_base,
                  TCON_CONTAINER(concan, struct outer, inner)) info;

diff --git a/ccan/tcon/test/compile_fail-container3.c b/ccan/tcon/test/compile_fail-container3.c
index 97473c8caeb89e2e7455aadabac0482b56eea4d3..9185225a9361903e25e86ce616e31da0e502e577 100644 (file)
--- a/ccan/tcon/test/compile_fail-container3.c
+++ b/ccan/tcon/test/compile_fail-container3.c
@@ -22,7 +22,7 @@ struct info_tcon {
        TCON(TCON_CONTAINER(concan, struct outer, inner));
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct info_tcon info;
        struct outer ovar;

diff --git a/ccan/tcon/test/compile_fail-container3w.c b/ccan/tcon/test/compile_fail-container3w.c
index 6930b436d984c5fe8e833b9cb81efd26304a0df9..958e5c8b3dca47c67c1f23aa25fe9fc29e759e90 100644 (file)
--- a/ccan/tcon/test/compile_fail-container3w.c
+++ b/ccan/tcon/test/compile_fail-container3w.c
@@ -17,7 +17,7 @@ struct info_base {
        char *infop;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        TCON_WRAP(struct info_base,
                  TCON_CONTAINER(concan, struct outer, inner)) info;

diff --git a/ccan/tcon/test/compile_fail-container4.c b/ccan/tcon/test/compile_fail-container4.c
index 838ce9b17696210669b5441e780c5244d597c07a..b11e8efcd8bc6eac7eda019b0881e24f17fddacc 100644 (file)
--- a/ccan/tcon/test/compile_fail-container4.c
+++ b/ccan/tcon/test/compile_fail-container4.c
@@ -22,7 +22,7 @@ struct info_tcon {
        TCON(TCON_CONTAINER(concan, struct outer, inner));
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct info_tcon info;
        struct outer ovar;

diff --git a/ccan/tcon/test/compile_fail-container4w.c b/ccan/tcon/test/compile_fail-container4w.c
index 0d7b367b99305700569e22a583ffb012078c5613..d33ce1e5216a2e6cac2c9856b2d158800862320f 100644 (file)
--- a/ccan/tcon/test/compile_fail-container4w.c
+++ b/ccan/tcon/test/compile_fail-container4w.c
@@ -17,7 +17,7 @@ struct info_base {
        char *infop;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        TCON_WRAP(struct info_base,
                  TCON_CONTAINER(concan, struct outer, inner)) info;

diff --git a/ccan/tcon/test/compile_fail-tcon_cast.c b/ccan/tcon/test/compile_fail-tcon_cast.c
index 3df0333ca047422eef3d83de1ea3b68063ab3df5..0d83ba3fa185cde98b4a83fed0ec2494dfe7136b 100644 (file)
--- a/ccan/tcon/test/compile_fail-tcon_cast.c
+++ b/ccan/tcon/test/compile_fail-tcon_cast.c
@@ -10,7 +10,7 @@ struct int_and_charp_container {
        TCON(int *tc1; char *tc2);
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct int_and_charp_container icon;
 #ifdef FAIL

diff --git a/ccan/tcon/test/compile_fail-tcon_cast_wrap.c b/ccan/tcon/test/compile_fail-tcon_cast_wrap.c
index f24cb01b8d791067a25b5f208a347172f4bf8b16..c9255791a1a5981bca55fc521468827a3d2d24c9 100644 (file)
--- a/ccan/tcon/test/compile_fail-tcon_cast_wrap.c
+++ b/ccan/tcon/test/compile_fail-tcon_cast_wrap.c
@@ -5,7 +5,7 @@ struct container {
        void *p;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        TCON_WRAP(struct container,
                  int *tc1; char *tc2) icon;

diff --git a/ccan/tcon/test/compile_fail-wrap.c b/ccan/tcon/test/compile_fail-wrap.c
index 26da13c3e0b9fe256a46acc21461d3f5e7b27dcf..96010e6cc51277038610d49ea8f6097e1fb35b60 100644 (file)
--- a/ccan/tcon/test/compile_fail-wrap.c
+++ b/ccan/tcon/test/compile_fail-wrap.c
@@ -5,7 +5,7 @@ struct container {
        void *p;
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        TCON_WRAP(struct container, int *canary) icon;
 #ifdef FAIL

diff --git a/ccan/tcon/test/compile_fail.c b/ccan/tcon/test/compile_fail.c
index 683bbd62ffdefb85434b04c3fa716dbd78d30a16..b17d9d2e556f5224f077bc5309db5843d71435af 100644 (file)
--- a/ccan/tcon/test/compile_fail.c
+++ b/ccan/tcon/test/compile_fail.c
@@ -10,7 +10,7 @@ struct int_container {
        TCON(int *canary);
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct int_container icon;
 #ifdef FAIL

diff --git a/ccan/tcon/test/compile_ok-container.c b/ccan/tcon/test/compile_ok-container.c
index a8347f7aa8f5c302483800b671b8050cd8e12642..8afacabccc9594e8483cf9db4e4debe6f385fea8 100644 (file)
--- a/ccan/tcon/test/compile_ok-container.c
+++ b/ccan/tcon/test/compile_ok-container.c
@@ -22,7 +22,7 @@ struct info_tcon {
        TCON(TCON_CONTAINER(fi, struct outer, inner));
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        /* Const should work! */
        const struct outer *ovar = NULL;

diff --git a/ccan/tcon/test/compile_ok-sizeof.c b/ccan/tcon/test/compile_ok-sizeof.c
index 64ccc136ea53ed86a2fc55ba839862bdbb6da72c..9c4bf9ac87d603d74b64448d043e4ff80330a6e2 100644 (file)
--- a/ccan/tcon/test/compile_ok-sizeof.c
+++ b/ccan/tcon/test/compile_ok-sizeof.c
@@ -16,7 +16,7 @@ struct charp_and_int_container {
        TCON(int tc1; char *tc2);
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct int_container icon;
        struct charp_and_int_container cicon;

diff --git a/ccan/tcon/test/compile_ok-value.c b/ccan/tcon/test/compile_ok-value.c
index d9c911e6d0dba5d0c2e6af802bcc322aa0a2c0ae..9620bcbd3d13a65ac9090b8813241582ee1dd1f3 100644 (file)
--- a/ccan/tcon/test/compile_ok-value.c
+++ b/ccan/tcon/test/compile_ok-value.c
@@ -26,7 +26,7 @@ struct offs_container {
             TCON_VALUE(off2, offsetof(struct other_struct, x2)));
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct val_container valcon;
        struct offs_container offscon;

diff --git a/ccan/tcon/test/compile_ok-void.c b/ccan/tcon/test/compile_ok-void.c
index 694a53b533d87db6478dda4557d77c2b206e1ad6..442ca6599938b2877b5615fc0bf036b26c2e1c6f 100644 (file)
--- a/ccan/tcon/test/compile_ok-void.c
+++ b/ccan/tcon/test/compile_ok-void.c
@@ -15,6 +15,7 @@ int main(int argc, char *argv[])
        struct void_container vcon;
        TCON_WRAP(struct container, void *canary) vconw;
 
+       (void)argc;
        tcon_check(&vcon, canary, NULL)->raw.p = NULL;
        tcon_check(&vcon, canary, argv[0])->raw.p = NULL;
        tcon_check(&vcon, canary, main)->raw.p = NULL;

diff --git a/ccan/tcon/test/compile_ok.c b/ccan/tcon/test/compile_ok.c
index f3fe2c6f8a1a09b4f7d3b2b9f6aee5f285e1d56f..6ba5f4c1458a793879e9a76cffa2448235f06bae 100644 (file)
--- a/ccan/tcon/test/compile_ok.c
+++ b/ccan/tcon/test/compile_ok.c
@@ -23,6 +23,7 @@ int main(int argc, char *argv[])
        TCON_WRAP(struct container, int tc) iconw;
        TCON_WRAP(struct container, int tc1; char *tc2) ciconw;
 
+       (void)argc;
        tcon_check(&icon, tc, 7)->raw.p = NULL;
        tcon_check(&cicon, tc1, 7)->raw.p = argv[0];
        tcon_check(&cicon, tc2, argv[0])->raw.p = argv[0];

diff --git a/ccan/tcon/test/run-container.c b/ccan/tcon/test/run-container.c
index 88bb2a1c53cb0d185e859d9b51f5dcb326d30388..c08bad5c840aa21642e71a1f46af2fa7e011ff38 100644 (file)
--- a/ccan/tcon/test/run-container.c
+++ b/ccan/tcon/test/run-container.c
@@ -28,7 +28,7 @@ struct info_tcon {
             TCON_CONTAINER(fi2, struct outer0, inner));
 };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct info_tcon info;
        TCON_WRAP(struct info_base,

diff --git a/ccan/tcon/test/run-wrap.c b/ccan/tcon/test/run-wrap.c
index 0d5cfef61fc018aa4001cb125cfa585bac9d1515..3493e5ac77ccbce792e436fe3b6546d24b73b2f7 100644 (file)
--- a/ccan/tcon/test/run-wrap.c
+++ b/ccan/tcon/test/run-wrap.c
@@ -4,7 +4,7 @@
 
 typedef TCON_WRAP(int, char *canary) canaried_int;
 
-int main(int argc, char *argv[])
+int main(void)
 {
        canaried_int ci = TCON_WRAP_INIT(0);
 

diff --git a/ccan/time/test/run-check.c b/ccan/time/test/run-check.c
index 3c2e282fd4b4b40e47962066b6c45d6ef018ffc7..c134afc3ec1ac655e8913d361815cebbffd9597c 100644 (file)
--- a/ccan/time/test/run-check.c
+++ b/ccan/time/test/run-check.c
@@ -17,10 +17,11 @@ void abort(void)
 int main(void)
 {
        struct timeabs t1, t2, epoch = { { 0, 0 } };
+       struct timemono t1m, t2m;
        struct timerel t3, t4, zero = { { 0, 0 } };
        int fds[2];
 
-       plan_tests(64);
+       plan_tests(69);
 
        /* Test time_now */
        t1 = time_now();
@@ -43,6 +44,21 @@ int main(void)
        ok1(timerel_eq(t3, t3));
        ok1(!timerel_eq(t3, zero));
 
+       /* Test time_mono */
+       t1m = time_mono();
+       t2m = time_mono();
+
+       ok1(!time_less_(t2m.ts, t1m.ts));
+
+       t3.ts.tv_sec = 1;
+       t3.ts.tv_nsec = 0;
+
+       ok1(time_less(timemono_between(t2m, t1m), t3));
+       ok1(time_less(timemono_since(t1m), t3));
+
+       ok1(timemono_add(t1m, t3).ts.tv_sec == t1m.ts.tv_sec + 1);
+       ok1(timemono_add(t2m, t3).ts.tv_nsec == t2m.ts.tv_nsec);
+
        /* Make sure t2 > t1. */
        t3.ts.tv_sec = 0;
        t3.ts.tv_nsec = 1;
@@ -156,7 +172,8 @@ int main(void)
        ok1(t3.ts.tv_sec == 2);
        ok1(t3.ts.tv_nsec == 147483648);
 
-       pipe(fds);
+       if (pipe(fds) != 0)
+               exit(1);
 
        fflush(stdout);
        switch (fork()) {

diff --git a/ccan/time/test/run-monotonic.c b/ccan/time/test/run-monotonic.c
index ed70f3dbb5bddc19e15ed460c250f43fac236456..2da492d441b0160731ce4f431d31031c9b7e67a3 100644 (file)
--- a/ccan/time/test/run-monotonic.c
+++ b/ccan/time/test/run-monotonic.c
@@ -7,7 +7,7 @@ int main(void)
        struct timemono t1, t2;
        struct timerel t3;
 
-       plan_tests(2);
+       plan_tests(5);
 
        /* Test time_mono */
        t1 = time_mono();
@@ -18,7 +18,11 @@ int main(void)
        t3.ts.tv_sec = 1;
        t3.ts.tv_nsec = 0;
 
-       ok1(time_less(timemono_between(t1, t2), t3));
+       ok1(time_less(timemono_between(t2, t1), t3));
+       ok1(time_less(timemono_since(t1), t3));
+
+       ok1(timemono_add(t1, t3).ts.tv_sec == t1.ts.tv_sec + 1);
+       ok1(timemono_add(t2, t3).ts.tv_nsec == t2.ts.tv_nsec);
 
        return exit_status();
 }

diff --git a/ccan/time/time.c b/ccan/time/time.c
index d0542f5654e86f06e69bc40c530ce0c989643e92..27f0d52a30987df194ea710e8f4af6a4cd74dfc4 100644 (file)
--- a/ccan/time/time.c
+++ b/ccan/time/time.c
@@ -33,7 +33,7 @@ struct timemono time_mono(void)
 #else /* Best we can do */
        ret.ts = time_now().ts;
 #endif /* !HAVE_TIME_MONOTONIC */
-       return ret;
+       return TIMEMONO_CHECK(ret);
 }
 
 struct timerel time_divide(struct timerel t, unsigned long div)
@@ -128,3 +128,11 @@ struct timeabs timeabs_check(struct timeabs t, const char *abortstr)
        ret.ts = time_check_(t.ts, abortstr);
        return ret;
 }
+
+struct timemono timemono_check(struct timemono t, const char *abortstr)
+{
+       struct timemono ret;
+
+       ret.ts = time_check_(t.ts, abortstr);
+       return ret;
+}

diff --git a/ccan/time/time.h b/ccan/time/time.h
index 5c916f4c4c2ef04b9648791d862bb3eea731a6cd..70ebdc9a7751ca5be434329421618c58f177c9c7 100644 (file)
--- a/ccan/time/time.h
+++ b/ccan/time/time.h
@@ -22,10 +22,13 @@ struct timespec {
        timerel_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ")
 #define TIMEABS_CHECK(t) \
        timeabs_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ")
+#define TIMEMONO_CHECK(t) \
+       timemono_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ")
 #else
 #define TIME_CHECK(t) (t)
 #define TIMEREL_CHECK(t) (t)
 #define TIMEABS_CHECK(t) (t)
+#define TIMEMONO_CHECK(t) (t)
 #endif
 
 /**
@@ -95,7 +98,7 @@ struct timerel timerel_check(struct timerel in, const char *abortstr);
 
 /**
  * timeabs_check - check if an absolute time is malformed.
- * @in: the relative time to check (returned)
+ * @in: the absolute time to check (returned)
  * @abortstr: the string to print to stderr before aborting (if set).
  *
  * This can be used to make sure a time isn't negative and doesn't
@@ -113,6 +116,26 @@ struct timerel timerel_check(struct timerel in, const char *abortstr);
  */
 struct timeabs timeabs_check(struct timeabs in, const char *abortstr);
 
+/**
+ * timemono_check - check if a monotonic time is malformed.
+ * @in: the monotonic time to check (returned)
+ * @abortstr: the string to print to stderr before aborting (if set).
+ *
+ * This can be used to make sure a time isn't negative and doesn't
+ * have a tv_nsec >= 1000000000.  If it is, and @abortstr is non-NULL,
+ * that will be printed and abort() is called.  Otherwise, if
+ * @abortstr is NULL then the returned timemono will be normalized and
+ * tv_sec set to 0 if it was negative.
+ *
+ * Note that if ccan/time is compiled with DEBUG, then it will call this
+ * for all passed and returned times.
+ *
+ * Example:
+ *     printf("Now is %lu seconds since mono start\n",
+ *             (long)timemono_check(time_mono(), "time_mono failed?").ts.tv_sec);
+ */
+struct timemono timemono_check(struct timemono in, const char *abortstr);
+
 /**
  * time_now - return the current time
  *
@@ -127,7 +150,7 @@ struct timeabs time_now(void);
  * This value is only really useful for measuring time intervals.
  *
  * See also:
- *     time_since()
+ *     timemono_since()
  */
 struct timemono time_mono(void);
 
@@ -231,6 +254,32 @@ static inline bool timeabs_eq(struct timeabs a, struct timeabs b)
                && a.ts.tv_nsec == b.ts.tv_nsec;
 }
 
+/**
+ * timemono_eq - is a equal to b?
+ * @a: one monotonic time.
+ * @b: another monotonic time.
+ *
+ * Example:
+ *     #include <sys/types.h>
+ *     #include <sys/wait.h>
+ *
+ *     // Can we fork in under a nanosecond?
+ *     static bool fast_fork(void)
+ *     {
+ *             struct timemono start = time_mono();
+ *             if (fork() != 0) {
+ *                     exit(0);
+ *             }
+ *             wait(NULL);
+ *             return timemono_eq(start, time_mono());
+ *     }
+ */
+static inline bool timemono_eq(struct timemono a, struct timemono b)
+{
+       return TIMEMONO_CHECK(a).ts.tv_sec == TIMEMONO_CHECK(b).ts.tv_sec
+               && a.ts.tv_nsec == b.ts.tv_nsec;
+}
+
 /**
  * timerel_eq - is a equal to b?
  * @a: one relative time.
@@ -320,6 +369,17 @@ static inline struct timerel timemono_between(struct timemono recent,
        return t;
 }
 
+/**
+ * timemono_since - elapsed monotonic time since @old
+ * @old: a monotonic time from the past.
+ */
+static inline struct timerel timemono_since(struct timemono old)
+{
+       struct timemono now = time_mono();
+
+       return timemono_between(now, TIMEMONO_CHECK(old));
+}
+
 /**
  * timeabs_sub - subtract a relative time from an absolute time
  * @abs: the absolute time.
@@ -377,6 +437,28 @@ static inline struct timeabs timeabs_add(struct timeabs a, struct timerel b)
        return t;
 }
 
+/**
+ * timemono_add - add a relative to a monotonic time
+ * @a: the monotonic time.
+ * @b: a relative time.
+ *
+ * The times must not overflow, or the results are undefined.
+ *
+ * Example:
+ *     // We do one every second.
+ *     static struct timemono next_timem(void)
+ *     {
+ *             return timemono_add(time_mono(), time_from_msec(1000));
+ *     }
+ */
+static inline struct timemono timemono_add(struct timemono a, struct timerel b)
+{
+       struct timemono t;
+
+       t.ts = time_add_(a.ts, b.ts);
+       return t;
+}
+
 /**
  * timerel_add - add two relative times
  * @a: one relative time.

diff --git a/ccan/timer/_info b/ccan/timer/_info
index 420aba1145ad46372d6a34172c5a837d32800a2b..9f5ec7a22809efa6de4d3806820f1b1ed78b2485 100644 (file)
--- a/ccan/timer/_info
+++ b/ccan/timer/_info
@@ -31,21 +31,21 @@
  *             struct timer *t;
  *             struct timed_string *s;
  *
- *             timers_init(&timers, time_now());
+ *             (void)argc;
+ *             timers_init(&timers, time_mono());
  *             list_head_init(&strings);
  *
  *             while (argv[1]) {
  *                     s = malloc(sizeof(*s));
  *                     s->string = argv[1];
- *                     timer_add(&timers, &s->timer,
- *                               timeabs_add(time_now(),
- *                                           time_from_msec(atol(argv[2]))));
+ *                     timer_addrel(&timers, &s->timer,
+ *                                  time_from_msec(atol(argv[2])));
  *                     list_add_tail(&strings, &s->node);
  *                     argv += 2;
  *             }
  *
  *             while (!list_empty(&strings)) {
- *                     struct timeabs now = time_now();
+ *                     struct timemono now = time_mono();
  *                     list_for_each(&strings, s, node)
  *                             printf("%s", s->string);
  *                     while ((t = timers_expire(&timers, now)) != NULL) {

diff --git a/ccan/timer/test/run-add.c b/ccan/timer/test/run-add.c
index e97bf781ddcc82e644d82165b9d7d373deee351c..9ad44b7e347608f9040310a40292271669b76a80 100644 (file)
--- a/ccan/timer/test/run-add.c
+++ b/ccan/timer/test/run-add.c
@@ -20,7 +20,7 @@ int main(void)
        struct timer t;
        uint64_t diff;
        unsigned int i;
-       struct timeabs epoch = { { 0, 0 } };
+       struct timemono epoch = { { 0, 0 } };
 
        /* This is how many tests you plan to run */
        plan_tests(2 + (18 + (MAX_ORD - 4) * 3) * (18 + (MAX_ORD - 4) * 3));
@@ -38,7 +38,7 @@ int main(void)
                for (timers.base = 0;
                     timers.base < (1ULL << MAX_ORD)+2;
                     timers.base = next(timers.base)) {
-                       timer_add(&timers, &t, grains_to_time(timers.base + diff));
+                       timer_addmono(&timers, &t, grains_to_time(timers.base + diff));
                        ok1(timers_check(&timers, NULL));
                        timer_del(&timers, &t);
                }

diff --git a/ccan/timer/test/run-corrupt.c b/ccan/timer/test/run-corrupt.c
index ee9660481ea92655618f30eeb7f0b7fd6328e6d5..9fd735b9edfaf420e1da7769d3fc26fb20b36d94 100644 (file)
--- a/ccan/timer/test/run-corrupt.c
+++ b/ccan/timer/test/run-corrupt.c
@@ -7,25 +7,25 @@
 static void new_timer(struct timers *timers, unsigned long nsec)
 {
        struct timer *timer;
-       struct timeabs when;
+       struct timemono when;
 
        timer = malloc(sizeof(*timer));
        timer_init(timer);
        when.ts.tv_sec = 0; when.ts.tv_nsec = nsec;
-       timer_add(timers, timer, when);
+       timer_addmono(timers, timer, when);
 }
 
 static void update_and_expire(struct timers *timers)
 {
-       struct timeabs when;
+       struct timemono when;
 
        timer_earliest(timers, &when);
        free(timers_expire(timers, when));
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
-       struct timeabs when;
+       struct timemono when;
        struct timers timers;
 
        plan_tests(7);

diff --git a/ccan/timer/test/run-corrupt2.c b/ccan/timer/test/run-corrupt2.c
index c2f32976165f456fe665b41be4ecbc47116ca4df..02e98ff9288dfa9f6d295c1a56b153e865a31db4 100644 (file)
--- a/ccan/timer/test/run-corrupt2.c
+++ b/ccan/timer/test/run-corrupt2.c
@@ -5,9 +5,9 @@
 #include <ccan/tap/tap.h>
 
 /* This is the original pre-cut-down dump. */
-int main(int argc, char *argv[])
+int main(void)
 {
-       struct timeabs when;
+       struct timemono when;
        struct timers timers;
        struct timer *timer;
 
@@ -19,1611 +19,1611 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 18000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 13000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 90000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -1631,553 +1631,553 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2185,165 +2185,165 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2351,225 +2351,225 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2577,37 +2577,37 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2615,41 +2615,41 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2659,71 +2659,71 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2731,25 +2731,25 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2761,115 +2761,115 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2877,73 +2877,73 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -2951,49 +2951,49 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3003,35 +3003,35 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3039,19 +3039,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3059,33 +3059,33 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3093,11 +3093,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3105,53 +3105,53 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3159,15 +3159,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3177,15 +3177,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3195,31 +3195,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3227,63 +3227,63 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3293,7 +3293,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3301,79 +3301,79 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3383,7 +3383,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3401,15 +3401,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3423,99 +3423,99 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3523,31 +3523,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3557,15 +3557,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3573,15 +3573,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3591,23 +3591,23 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3621,27 +3621,27 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3653,39 +3653,39 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3695,17 +3695,17 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3727,21 +3727,21 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3755,11 +3755,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3767,23 +3767,23 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3791,57 +3791,57 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3855,51 +3855,51 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3907,41 +3907,41 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3957,7 +3957,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3965,27 +3965,27 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -3995,85 +3995,85 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4081,61 +4081,61 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4149,21 +4149,21 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4175,15 +4175,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4191,31 +4191,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4231,21 +4231,21 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4255,19 +4255,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4275,15 +4275,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4299,7 +4299,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4307,11 +4307,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4321,49 +4321,49 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4371,69 +4371,69 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 307000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4441,11 +4441,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4453,11 +4453,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4467,7 +4467,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4477,25 +4477,25 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4517,37 +4517,37 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 270000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 237000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4555,7 +4555,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4563,17 +4563,17 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4581,11 +4581,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4595,45 +4595,45 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 117000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4643,33 +4643,33 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 312000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 273000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4677,11 +4677,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4689,19 +4689,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4719,15 +4719,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4735,11 +4735,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 317000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4767,31 +4767,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 291000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4815,33 +4815,33 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4867,19 +4867,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4893,57 +4893,57 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4967,19 +4967,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 322000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -4995,11 +4995,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5011,37 +5011,37 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5053,11 +5053,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5071,7 +5071,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5079,29 +5079,29 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 321000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5125,19 +5125,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5155,31 +5155,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 290000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5195,15 +5195,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5213,35 +5213,35 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 282000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5255,31 +5255,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 338000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5291,7 +5291,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 300000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5315,11 +5315,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5329,7 +5329,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5337,19 +5337,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5357,37 +5357,37 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5401,25 +5401,25 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 328000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5429,27 +5429,27 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5459,31 +5459,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 243000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5493,17 +5493,17 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5525,11 +5525,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5541,15 +5541,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5565,7 +5565,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5609,27 +5609,27 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5639,23 +5639,23 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 323000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 320000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5673,27 +5673,27 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 351000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5703,43 +5703,43 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 319000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5749,11 +5749,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5769,19 +5769,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5789,15 +5789,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5807,19 +5807,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5867,15 +5867,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5883,73 +5883,73 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 360000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 349000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5959,29 +5959,29 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 327000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -5997,23 +5997,23 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -6021,7 +6021,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -6031,17 +6031,17 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -6065,19 +6065,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -6107,33 +6107,33 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 314000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 368000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 335000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -6141,7 +6141,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        free(timers_expire(&timers, when)); timers_check(&timers, "expire");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
@@ -6153,23 +6153,23 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when); timers_check(&timers, "add");
+       timer_addmono(&timers, timer, when); timers_check(&timers, "add");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
        timer_earliest(&timers, &when); timers_check(&timers, "earliest");
 

diff --git a/ccan/timer/test/run-expiry.c b/ccan/timer/test/run-expiry.c
index 1c276c2c9016332d1101343f815980bae9d177d2..39b5b5eafd5b00d06cc81bca395b46853fa64cd0 100644 (file)
--- a/ccan/timer/test/run-expiry.c
+++ b/ccan/timer/test/run-expiry.c
@@ -14,7 +14,7 @@ int main(void)
        timers_init(&timers, grains_to_time(1364984760903400ULL));
        ok1(timers.base == 1364984760903400ULL);
        timer_init(&t);
-       timer_add(&timers, &t, grains_to_time(1364984761003398ULL));
+       timer_addmono(&timers, &t, grains_to_time(1364984761003398ULL));
        ok1(t.time == 1364984761003398ULL);
        ok1(timers.first == 1364984761003398ULL);
        ok1(!timers_expire(&timers, grains_to_time(1364984760903444ULL)));

diff --git a/ccan/timer/test/run-ff.c b/ccan/timer/test/run-ff.c
index 49c6e3744c1e3e9991e9fea9db09f5ac2f3decdd..37f035da4ba167c2cd6cd9bc696877b889784ab1 100644 (file)
--- a/ccan/timer/test/run-ff.c
+++ b/ccan/timer/test/run-ff.c
@@ -3,10 +3,10 @@
 #include <ccan/timer/timer.c>
 #include <ccan/tap/tap.h>
 
-static struct timeabs timeabs_from_usec(unsigned long long usec)
+static struct timemono timemono_from_usec(unsigned long long usec)
 {
-       struct timeabs epoch = { { 0, 0 } };
-       return timeabs_add(epoch, time_from_usec(usec));
+       struct timemono epoch = { { 0, 0 } };
+       return timemono_add(epoch, time_from_usec(usec));
 }
 
 int main(void)
@@ -17,13 +17,13 @@ int main(void)
        /* This is how many tests you plan to run */
        plan_tests(3);
 
-       timers_init(&timers, timeabs_from_usec(1364726722653919ULL));
+       timers_init(&timers, timemono_from_usec(1364726722653919ULL));
        timer_init(&t);
-       timer_add(&timers, &t, timeabs_from_usec(1364726722703919ULL));
-       ok1(!timers_expire(&timers, timeabs_from_usec(1364726722653920ULL)));
-       expired = timers_expire(&timers, timeabs_from_usec(1364726725454187ULL));
+       timer_addmono(&timers, &t, timemono_from_usec(1364726722703919ULL));
+       ok1(!timers_expire(&timers, timemono_from_usec(1364726722653920ULL)));
+       expired = timers_expire(&timers, timemono_from_usec(1364726725454187ULL));
        ok1(expired == &t);
-       ok1(!timers_expire(&timers, timeabs_from_usec(1364726725454187ULL)));
+       ok1(!timers_expire(&timers, timemono_from_usec(1364726725454187ULL)));
        timers_cleanup(&timers);
 
        /* This exits depending on whether all tests passed */

diff --git a/ccan/timer/test/run-original-corrupt.c b/ccan/timer/test/run-original-corrupt.c
index 8bd2b428f38c27543bf295dab564236aa04b1138..8a447c847790aedcb455ec5e28cb1827ffd28b18 100644 (file)
--- a/ccan/timer/test/run-original-corrupt.c
+++ b/ccan/timer/test/run-original-corrupt.c
@@ -5,9 +5,9 @@
 #include <ccan/tap/tap.h>
 
 /* This is the original pre-cut-down dump. */
-int main(int argc, char *argv[])
+int main(void)
 {
-       struct timeabs when;
+       struct timemono when;
        struct timers timers;
        struct timer *timer;
 
@@ -19,1611 +19,1611 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 18000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 13000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 90000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -1631,553 +1631,553 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2185,165 +2185,165 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2351,225 +2351,225 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2577,37 +2577,37 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2615,41 +2615,41 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2659,71 +2659,71 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2731,25 +2731,25 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2761,115 +2761,115 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2877,73 +2877,73 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -2951,49 +2951,49 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3003,35 +3003,35 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3039,19 +3039,19 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3059,33 +3059,33 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3093,11 +3093,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3105,53 +3105,53 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3159,15 +3159,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3177,15 +3177,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3195,31 +3195,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3227,63 +3227,63 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3293,7 +3293,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3301,79 +3301,79 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3383,7 +3383,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3401,15 +3401,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3423,99 +3423,99 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3523,31 +3523,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3557,15 +3557,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3573,15 +3573,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3591,23 +3591,23 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3621,27 +3621,27 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3653,39 +3653,39 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3695,17 +3695,17 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3727,21 +3727,21 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3755,11 +3755,11 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3767,23 +3767,23 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3791,57 +3791,57 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3855,51 +3855,51 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3907,41 +3907,41 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3957,7 +3957,7 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3965,27 +3965,27 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -3995,85 +3995,85 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -4081,61 +4081,61 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -4149,21 +4149,21 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -4175,15 +4175,15 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -4191,31 +4191,31 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        timer_earliest(&timers, &when);
@@ -4231,21 +4231,21 @@ int main(int argc, char *argv[])
        when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));
        when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
        timer = malloc(sizeof(*timer));
        timer_init(timer);
-       timer_add(&timers, timer, when);
+       timer_addmono(&timers, timer, when);
        ok1(timers_check(&timers, NULL));
        timer_earliest(&timers, &when);
        free(timers_expire(&timers, when));

diff --git a/ccan/timer/test/run.c b/ccan/timer/test/run.c
index e2d467eb0ebdb4a662c732f277a6c948f69403b8..ca0435e3015bab0933c60a29dea3a326901dbc27 100644 (file)
--- a/ccan/timer/test/run.c
+++ b/ccan/timer/test/run.c
@@ -1,25 +1,31 @@
 #define CCAN_TIMER_DEBUG
 #include <ccan/timer/timer.h>
+#include <ccan/time/time.h>
+
+#define time_mono() fake_mono_time
+
+static struct timemono fake_mono_time;
+
 /* Include the C files directly. */
 #include <ccan/timer/timer.c>
 #include <ccan/tap/tap.h>
 
-static struct timeabs timeabs_from_nsec(unsigned long long nsec)
+static struct timemono timemono_from_nsec(unsigned long long nsec)
 {
-       struct timeabs epoch = { { 0, 0 } };
-       return timeabs_add(epoch, time_from_nsec(nsec));
+       struct timemono epoch = { { 0, 0 } };
+       return timemono_add(epoch, time_from_nsec(nsec));
 }
 
 int main(void)
 {
        struct timers timers;
        struct timer t[64];
-       struct timeabs earliest;
+       struct timemono earliest;
        uint64_t i;
-       struct timeabs epoch = { { 0, 0 } };
+       const struct timemono epoch = { { 0, 0 } };
 
        /* This is how many tests you plan to run */
-       plan_tests(488);
+       plan_tests(495);
 
        timers_init(&timers, epoch);
        ok1(timers_check(&timers, NULL));
@@ -29,10 +35,10 @@ int main(void)
        /* timer_del can be called immediately after init. */
        timer_del(&timers, &t[0]);
 
-       timer_add(&timers, &t[0], timeabs_from_nsec(1));
+       timer_addmono(&timers, &t[0], timemono_from_nsec(1));
        ok1(timers_check(&timers, NULL));
        ok1(timer_earliest(&timers, &earliest));
-       ok1(timeabs_eq(earliest, grains_to_time(t[0].time)));
+       ok1(timemono_eq(earliest, grains_to_time(t[0].time)));
        timer_del(&timers, &t[0]);
        ok1(timers_check(&timers, NULL));
        ok1(!timer_earliest(&timers, &earliest));
@@ -43,10 +49,10 @@ int main(void)
        /* Check timer ordering. */
        for (i = 0; i < 32; i++) {
                timer_init(&t[i*2]);
-               timer_add(&timers, &t[i*2], timeabs_from_nsec(1ULL << i));
+               timer_addmono(&timers, &t[i*2], timemono_from_nsec(1ULL << i));
                ok1(timers_check(&timers, NULL));
                timer_init(&t[i*2+1]);
-               timer_add(&timers, &t[i*2+1], timeabs_from_nsec((1ULL << i) + 1));
+               timer_addmono(&timers, &t[i*2+1], timemono_from_nsec((1ULL << i) + 1));
                ok1(timers_check(&timers, NULL));
        }
 
@@ -68,9 +74,9 @@ int main(void)
        for (i = 0; i < 32; i++) {
                uint64_t exp = (uint64_t)TIMER_GRANULARITY << i;
 
-               timer_add(&timers, &t[i*2], timeabs_from_nsec(exp));
+               timer_addmono(&timers, &t[i*2], timemono_from_nsec(exp));
                ok1(timers_check(&timers, NULL));
-               timer_add(&timers, &t[i*2+1], timeabs_from_nsec(exp + 1));
+               timer_addmono(&timers, &t[i*2+1], timemono_from_nsec(exp + 1));
                ok1(timers_check(&timers, NULL));
        }
 
@@ -90,7 +96,19 @@ int main(void)
        }
 
        ok1(!timer_earliest(&timers, &earliest));
-
+       ok1(timers_check(&timers, NULL));
+       timers_cleanup(&timers);
+       
+       /* Relative timers. */
+       timers_init(&timers, epoch);
+       fake_mono_time = timemono_from_nsec(TIMER_GRANULARITY);
+       timer_addrel(&timers, &t[0], time_from_sec(1));
+       ok1(timer_earliest(&timers, &earliest));
+       ok1(timers_check(&timers, NULL));
+       ok1(earliest.ts.tv_sec == 1 && earliest.ts.tv_nsec == TIMER_GRANULARITY);
+       ok1(timers_expire(&timers, earliest) == &t[0]);
+       ok1(!timer_earliest(&timers, &earliest));
+       ok1(timers_check(&timers, NULL));
        timers_cleanup(&timers);
 
        /* This exits depending on whether all tests passed */

diff --git a/ccan/timer/timer.c b/ccan/timer/timer.c
index 8d220a6a8c6f44893f12c76e95090c6f0998321d..91f46393958acef5b6e9dc10968f14344b35ab5d 100644 (file)
--- a/ccan/timer/timer.c
+++ b/ccan/timer/timer.c
@@ -12,15 +12,15 @@ struct timer_level {
        struct list_head list[PER_LEVEL];
 };
 
-static uint64_t time_to_grains(struct timeabs t)
+static uint64_t time_to_grains(struct timemono t)
 {
        return t.ts.tv_sec * ((uint64_t)1000000000 / TIMER_GRANULARITY)
                + (t.ts.tv_nsec / TIMER_GRANULARITY);
 }
 
-static struct timeabs grains_to_time(uint64_t grains)
+static struct timemono grains_to_time(uint64_t grains)
 {
-       struct timeabs t;
+       struct timemono t;
 
        t.ts.tv_sec = grains / (1000000000 / TIMER_GRANULARITY);
        t.ts.tv_nsec = (grains % (1000000000 / TIMER_GRANULARITY))
@@ -28,7 +28,7 @@ static struct timeabs grains_to_time(uint64_t grains)
        return t;
 }
 
-void timers_init(struct timers *timers, struct timeabs start)
+void timers_init(struct timers *timers, struct timemono start)
 {
        unsigned int i;
 
@@ -79,7 +79,26 @@ static bool list_node_initted(const struct list_node *n)
        return n->prev == n;
 }
 
-void timer_add(struct timers *timers, struct timer *t, struct timeabs when)
+void timer_addrel(struct timers *timers, struct timer *t, struct timerel rel)
+{
+       assert(list_node_initted(&t->list));
+
+       t->time = time_to_grains(timemono_add(time_mono(), rel));
+
+#if TIME_HAVE_MONOTONIC
+       assert(t->time >= timers->base);
+#else
+       /* Added in the past?  Treat it as imminent. */
+       if (t->time < timers->base)
+               t->time = timers->base;
+#endif
+       if (t->time < timers->first)
+               timers->first = t->time;
+
+       timer_add_raw(timers, t);
+}
+
+void timer_addmono(struct timers *timers, struct timer *t, struct timemono when)
 {
        assert(list_node_initted(&t->list));
 
@@ -95,7 +114,7 @@ void timer_add(struct timers *timers, struct timer *t, struct timeabs when)
 }
 
 /* FIXME: inline */
-void timer_del(struct timers *timers, struct timer *t)
+void timer_del(struct timers *timers UNNEEDED, struct timer *t)
 {
        list_del_init(&t->list);
 }
@@ -241,7 +260,7 @@ static bool update_first(struct timers *timers)
        return true;
 }
 
-bool timer_earliest(struct timers *timers, struct timeabs *first)
+bool timer_earliest(struct timers *timers, struct timemono *first)
 {
        if (!update_first(timers))
                return false;
@@ -298,7 +317,7 @@ static void timer_fast_forward(struct timers *timers, uint64_t time)
 }
 
 /* Returns an expired timer. */
-struct timer *timers_expire(struct timers *timers, struct timeabs expire)
+struct timer *timers_expire(struct timers *timers, struct timemono expire)
 {
        uint64_t now = time_to_grains(expire);
        unsigned int off;

diff --git a/ccan/timer/timer.h b/ccan/timer/timer.h
index e678f7f7dfcbf78274e89ecbefcdc8e320992f0b..5c40a3bbc1c9979251ad5c2b76ca6a0443c5926a 100644 (file)
--- a/ccan/timer/timer.h
+++ b/ccan/timer/timer.h
@@ -29,9 +29,9 @@ struct timer;
  * Example:
  *     struct timers timeouts;
  *
- *     timers_init(&timeouts, time_now());
+ *     timers_init(&timeouts, time_mono());
  */
-void timers_init(struct timers *timers, struct timeabs start);
+void timers_init(struct timers *timers, struct timemono start);
 
 /**
  * timers_cleanup - free allocations within timers struct.
@@ -56,19 +56,39 @@ void timers_cleanup(struct timers *timers);
 void timer_init(struct timer *t);
 
 /**
- * timer_add - insert a timer.
+ * timer_addrel - insert a relative timer.
  * @timers: the struct timers
  * @timer: the (initialized or timer_del'd) timer to add
- * @when: when @timer expires.
+ * @rel: when @timer expires (relative).
+ *
+ * This efficiently adds @timer to @timers, to expire @rel (rounded to
+ * TIMER_GRANULARITY nanoseconds) after the current time.  This
+ * is a convenient wrapper around timer_addmono().
+ *
+ * Example:
+ *     // Timeout in 100ms.
+ *     timer_addrel(&timeouts, &t, time_from_msec(100));
+ */
+void timer_addrel(struct timers *timers, struct timer *timer, struct timerel rel);
+
+/**
+ * timer_addmono - insert an absolute timer.
+ * @timers: the struct timers
+ * @timer: the (initialized or timer_del'd) timer to add
+ * @when: when @timer expires (absolute).
  *
  * This efficiently adds @timer to @timers, to expire @when (rounded to
  * TIMER_GRANULARITY nanoseconds).
  *
+ * Note that if @when is before time_mono(), then it will be set to expire
+ * immediately.
+ *
  * Example:
  *     // Timeout in 100ms.
- *     timer_add(&timeouts, &t, timeabs_add(time_now(), time_from_msec(100)));
+ *     timer_addmono(&timeouts, &t, timemono_add(time_mono(), time_from_msec(100)));
  */
-void timer_add(struct timers *timers, struct timer *timer, struct timeabs when);
+void timer_addmono(struct timers *timers, struct timer *timer,
+                  struct timemono when);
 
 /**
  * timer_del - remove a timer.
@@ -94,10 +114,10 @@ void timer_del(struct timers *timers, struct timer *timer);
  * timer (rounded to TIMER_GRANULARITY nanoseconds), and returns true.
  *
  * Example:
- *     struct timeabs next = { { (time_t)-1ULL, -1UL } };
+ *     struct timemono next = { { (time_t)-1ULL, -1UL } };
  *     timer_earliest(&timeouts, &next);
  */
-bool timer_earliest(struct timers *timers, struct timeabs *first);
+bool timer_earliest(struct timers *timers, struct timemono *first);
 
 /**
  * timers_expire - update timers structure and remove one expire timer.
@@ -118,11 +138,11 @@ bool timer_earliest(struct timers *timers, struct timeabs *first);
  * Example:
  *     struct timer *expired;
  *
- *     while ((expired = timers_expire(&timeouts, time_now())) != NULL)
+ *     while ((expired = timers_expire(&timeouts, time_mono())) != NULL)
  *             printf("Timer expired!\n");
  *
  */
-struct timer *timers_expire(struct timers *timers, struct timeabs expire);
+struct timer *timers_expire(struct timers *timers, struct timemono expire);
 
 /**
  * timers_check - check timer structure for consistency

diff --git a/ccan/typesafe_cb/_info b/ccan/typesafe_cb/_info
index 165852a3be2a1a4dd7c884dfbe48084991292ae1..b4f379dd48b020c29bf8f27c8da88a37831e619a 100644 (file)
--- a/ccan/typesafe_cb/_info
+++ b/ccan/typesafe_cb/_info
@@ -106,7 +106,7 @@
  *     // Silly game to find the longest chain of values.
  *     int main(int argc, char *argv[])
  *     {
- *             int i, run = 1, num = argv[1] ? atoi(argv[1]) : 0;
+ *             int i, run = 1, num = argc > 1 ? atoi(argv[1]) : 0;
  *     
  *             for (i = 1; i < 1024;) {
  *                     // Since run is an int, compiler checks "add" does too.

diff --git a/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c b/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c
index 11d42f4c6b670bb422949dd5045b3d0bb57b950a..746facaef3ed102989afcc9c7f0a71df063e6fc3 100644 (file)
--- a/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c
+++ b/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c
@@ -3,12 +3,13 @@
 
 static void _set_some_value(void *val)
 {
+       (void)val;
 }
 
 #define set_some_value(expr)                                           \
        _set_some_value(typesafe_cb_cast(void *, long, (expr)))
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        bool x = 0;

diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c
index c4033364d41c91bf565bfc52d71b22ab3434cc21..c9d47c50b17f38f4f534057a7091c677cc4cf2dd 100644 (file)
--- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c
+++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c
@@ -15,9 +15,10 @@ void _callback(void (*fn)(void *arg), void *arg)
 void my_callback(int something);
 void my_callback(int something)
 {
+       (void)something;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        /* This fails due to arg, not due to cast. */

diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c
index 81e36d7b87b901fb4922e5e3174ef466b242ec9a..5717f97be64cc0d5676f06f5dc2930b7d7a518ac 100644 (file)
--- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c
+++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c
@@ -3,6 +3,8 @@
 
 static void _register_callback(void (*cb)(void *arg), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback(cb, arg)                             \
@@ -10,9 +12,10 @@ static void _register_callback(void (*cb)(void *arg), void *arg)
 
 static void my_callback(char *p)
 {
+       (void)p;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        char str[] = "hello world";
 #ifdef FAIL

diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c
index 62b5f91e1807cdaaebff2a0a0f95bd554388add5..d85886c929f470ebad95f3400391424dc112c70c 100644 (file)
--- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c
+++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c
@@ -23,9 +23,10 @@ struct other {
 
 static void take_any(struct any *any)
 {
+       (void)any;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        struct other

diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c
index d2e6f2ab40a2544f4147ad8cb3f8570d6b644dac..7fa596cf23b489fd184a9cbb18d3091648114c8e 100644 (file)
--- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c
+++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c
@@ -4,12 +4,13 @@ void _set_some_value(void *val);
 
 void _set_some_value(void *val)
 {
+       (void)val;
 }
 
 #define set_some_value(expr)                                           \
        _set_some_value(typesafe_cb_cast(void *, unsigned long, (expr)))
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        int x = 0;

diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c
index 7d3530851d5b94ba1c69a932673b5241df3f0f1c..2100368f03292e41e94c5624d366f8de91b93e16 100644 (file)
--- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c
+++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c
@@ -3,15 +3,19 @@
 
 static void _register_callback(void (*cb)(void *arg, int x), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 #define register_callback(cb, arg)                             \
        _register_callback(typesafe_cb_postargs(void, void *, (cb), (arg), int), (arg))
 
 static void my_callback(char *p, int x)
 {
+       (void)p;
+       (void)x;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        int *p;

diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c
index bd55c6722c70bd62cf17f50d5354a1b822c9b483..d359a77f5b859b5f0c29c04fb994f02e0f628f37 100644 (file)
--- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c
+++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c
@@ -3,6 +3,8 @@
 
 static void _register_callback(void (*cb)(int x, void *arg), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback(cb, arg)                             \
@@ -10,9 +12,11 @@ static void _register_callback(void (*cb)(int x, void *arg), void *arg)
 
 static void my_callback(int x, char *p)
 {
+       (void)p;
+       (void)x;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
 #ifdef FAIL
        int *p;

diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c
index 265de8b14ee5a75761b4e6922aa7d30b04145f44..738ec96b277f7707e6de95abcebb0cbd3b9004d7 100644 (file)
--- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c
+++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c
@@ -5,12 +5,14 @@
 
 static void _register_callback(void (*cb)(const void *arg), const void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback(cb, arg)                             \
        _register_callback(typesafe_cb(void, const void *, (cb), (arg)), (arg))
 
-int main(int argc, char *argv[])
+int main(void)
 {
        register_callback(NULL, "hello world");
        return 0;

diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c
index aa50bad6a929a38f10daa11d9a647b8f47a34c10..bb71042c3b14914c41a0bbe4ea648fd159812c2c 100644 (file)
--- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c
+++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c
@@ -5,6 +5,8 @@
 
 static void _register_callback(void (*cb)(void *arg), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback(cb, arg)                             \
@@ -12,6 +14,8 @@ static void _register_callback(void (*cb)(void *arg), void *arg)
 
 static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback_pre(cb, arg)                                 \
@@ -19,6 +23,8 @@ static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg)
 
 static void _register_callback_post(void (*cb)(void *arg, int x), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback_post(cb, arg)                                        \
@@ -28,17 +34,22 @@ struct undefined;
 
 static void my_callback(struct undefined *undef)
 {
+       (void)undef;
 }
 
 static void my_callback_pre(int x, struct undefined *undef)
 {
+       (void)x;
+       (void)undef;
 }
 
 static void my_callback_post(struct undefined *undef, int x)
 {
+       (void)undef;
+       (void)x;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct undefined *handle = NULL;
 

diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c
index f6a2bfecbc235162bf59c8641f5162e1b174f125..1cb1057d823c954b25e9206bdc7b28781e293d3e 100644 (file)
--- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c
+++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c
@@ -5,6 +5,8 @@
 
 static void _register_callback(void (*cb)(void *arg), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback(cb, arg)                             \
@@ -12,6 +14,8 @@ static void _register_callback(void (*cb)(void *arg), void *arg)
 
 static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback_pre(cb, arg)                                 \
@@ -19,6 +23,8 @@ static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg)
 
 static void _register_callback_post(void (*cb)(void *arg, int x), void *arg)
 {
+       (void)cb;
+       (void)arg;
 }
 
 #define register_callback_post(cb, arg)                                        \
@@ -28,17 +34,22 @@ struct undefined;
 
 static void my_callback(struct undefined *undef)
 {
+       (void)undef;
 }
 
 static void my_callback_pre(int x, struct undefined *undef)
 {
+       (void)x;
+       (void)undef;
 }
 
 static void my_callback_post(struct undefined *undef, int x)
 {
+       (void)x;
+       (void)undef;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        struct undefined *handle = NULL;
        void (*cb)(struct undefined *undef) = my_callback;

diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c
index 4bb3b8bf10ad68218801024ef427052aba75a570..bd7b7d6532bffce5da05f1fbc31b055928691376 100644 (file)
--- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c
+++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c
@@ -19,9 +19,10 @@ struct any {
 
 static void take_any(struct any *any)
 {
+       (void)any;
 }
 
-int main(int argc, char *argv[])
+int main(void)
 {
        /* Otherwise we get unused warnings for these. */
        struct foo *foo = NULL;

diff --git a/ccan/typesafe_cb/test/run.c b/ccan/typesafe_cb/test/run.c
index 79863db84128c85a3079f5faad769e9db039bbf3..bebea400ebf9f5e32522627cbdf613a41326f0ad 100644 (file)
--- a/ccan/typesafe_cb/test/run.c
+++ b/ccan/typesafe_cb/test/run.c
@@ -89,7 +89,7 @@ struct callback_postargs cb_postargs
 = { typesafe_cb_postargs(void, void *, my_callback_postargs, 
                         (char *)(intptr_t)"hi", int, int), "hi" };
 
-int main(int argc, char *argv[])
+int main(void)
 {
        void *p = &dummy;
        unsigned long l = (unsigned long)p;

diff --git a/ccan/wwviaudio/_info b/ccan/wwviaudio/_info
index 5fb6beb9ec099f7eeda5aa47c838684a10aea882..501ad3d9cd979bb410ea789d5ae3e57076ad05ba 100644 (file)
--- a/ccan/wwviaudio/_info
+++ b/ccan/wwviaudio/_info
@@ -37,8 +37,8 @@
  *      wwviaudio_cancel_all_sounds();
  *      wwviaduio_stop_portaudio();
  *
+ * Ccanlint: examples_compile FAIL
  * License: GPL (v2 or any later version)
- *
  */
 int main(int argc, char *argv[])
 {

diff --git a/ccan/wwviaudio/wwviaudio.c b/ccan/wwviaudio/wwviaudio.c
index 5870411a39f40f1c13197f0b347267944d06a9cb..d6fabfbd761007ab661f120a0dc6fb16b859f78f 100644 (file)
--- a/ccan/wwviaudio/wwviaudio.c
+++ b/ccan/wwviaudio/wwviaudio.c
@@ -29,6 +29,7 @@
 #include <unistd.h>
 #include <string.h>
 #include <stdlib.h>
+#include <inttypes.h>
 
 #define WWVIAUDIO_DEFINE_GLOBALS
 #include "wwviaudio.h"
@@ -147,8 +148,8 @@ int wwviaudio_read_ogg_clip(int clipnum, char *filename)
        rc = ogg_to_pcm(filebuf, &clip[clipnum].sample, &samplesize,
                &sample_rate, &nchannels, &nframes);
        if (clip[clipnum].sample == NULL) {
-               printf("Can't get memory for sound data for %llu frames in %s\n",
-                       nframes, filebuf);
+               printf("Can't get memory for sound data for %"PRIu64
+                      " frames in %s\n", nframes, filebuf);
                goto error;
        }
 

diff --git a/tools/ccanlint/async.c b/tools/ccanlint/async.c
index d867079d0782c4f341e9af443517494f52f83c78..e5b9078dbda65c5c36b6b46636b4fad365fd586e 100644 (file)
--- a/tools/ccanlint/async.c
+++ b/tools/ccanlint/async.c
@@ -34,7 +34,7 @@ struct command {
        const void *ctx;
 };
 
-static void killme(int sig)
+static void killme(int sig UNNEEDED)
 {
        kill(-getpid(), SIGKILL);
 }

diff --git a/tools/ccanlint/ccanlint.c b/tools/ccanlint/ccanlint.c
index e2a687e06c410751996235e82192405726baa654..0ed969cb868ef8fc5f7f38f61465653244bfc1ed 100644 (file)
--- a/tools/ccanlint/ccanlint.c
+++ b/tools/ccanlint/ccanlint.c
@@ -84,12 +84,12 @@ static bool skip_test(struct dgraph_node *node, const char *why)
        return true;
 }
 
-static const char *dep_failed(struct manifest *m)
+static const char *dep_failed(struct manifest *m UNNEEDED)
 {
        return "dependency couldn't run";
 }
 
-static bool cannot_run(struct dgraph_node *node, void *all)
+static bool cannot_run(struct dgraph_node *node, void *all UNNEEDED)
 {
        struct ccanlint *c = container_of(node, struct ccanlint, node);
        c->can_run = dep_failed;
@@ -98,7 +98,7 @@ static bool cannot_run(struct dgraph_node *node, void *all)
 }
 
 struct run_info {
-       bool quiet;
+       bool noninteractive;
        unsigned int score, total;
        struct manifest *m;
        const char *prefix;
@@ -165,7 +165,7 @@ static bool run_test(struct dgraph_node *n, struct run_info *run)
        }
 
        assert(score->score <= score->total);
-       if ((!score->pass && !run->quiet)
+       if (!score->pass
            || (score->score < score->total && verbose)
            || verbose > 1) {
                printf("%s%s (%s): %s",
@@ -176,13 +176,13 @@ static bool run_test(struct dgraph_node *n, struct run_info *run)
                printf("\n");
        }
 
-       if ((!run->quiet && !score->pass) || verbose) {
+       if (!score->pass || verbose) {
                if (score->error) {
                        printf("%s%s", score->error,
                               strends(score->error, "\n") ? "" : "\n");
                }
        }
-       if (!run->quiet && score->score < score->total && i->handle)
+       if (!run->noninteractive && score->score < score->total && i->handle)
                i->handle(run->m, score);
 
        if (!score->pass) {
@@ -215,7 +215,7 @@ static void register_test(struct ccanlint *test)
        dgraph_init_node(&test->node);
 }
 
-static bool get_test(const char *member, struct ccanlint *i,
+static bool get_test(const char *member UNNEEDED, struct ccanlint *i,
                     struct ccanlint **ret)
 {
        if (tlist_empty(&i->node.edge[DGRAPH_TO])) {
@@ -252,7 +252,8 @@ bool is_excluded(const char *name)
        return find_test(name)->skip != NULL;
 }
 
-static bool init_deps(const char *member, struct ccanlint *c, void *unused)
+static bool init_deps(const char *member UNNEEDED,
+                     struct ccanlint *c, void *unused UNNEEDED)
 {
        char **deps = tal_strsplit(NULL, c->needs, " ", STR_EMPTY_OK);
        unsigned int i;
@@ -270,7 +271,7 @@ static bool init_deps(const char *member, struct ccanlint *c, void *unused)
        return true;
 }
 
-static bool check_names(const char *member, struct ccanlint *c,
+static bool check_names(const char *member UNNEEDED, struct ccanlint *c,
                        ccanlint_map_t *names)
 {
        if (!strmap_add(names, c->name, c))
@@ -299,7 +300,7 @@ static void init_tests(void)
        strmap_clear(&names);
 }
 
-static bool reset_test(struct dgraph_node *node, void *unused)
+static bool reset_test(struct dgraph_node *node, void *unused UNNEEDED)
 {
        struct ccanlint *c = container_of(node, struct ccanlint, node);
        c->skip = NULL;
@@ -312,7 +313,8 @@ static void reset_tests(struct dgraph_node *all)
        dgraph_traverse_to(all, reset_test, NULL);
 }
 
-static bool print_deps(const char *member, struct ccanlint *c, void *unused)
+static bool print_deps(const char *member UNNEEDED,
+                      struct ccanlint *c, void *unused UNNEEDED)
 {
        if (!tlist_empty(&c->node.edge[DGRAPH_FROM])) {
                struct dgraph_edge *e;
@@ -341,7 +343,7 @@ static void show_tmpdir(const char *dir)
        printf("You can find ccanlint working files in '%s'\n", dir);
 }
 
-static char *keep_tests(void *unused)
+static char *keep_tests(void *unused UNNEEDED)
 {
        keep_results = true;
 
@@ -359,7 +361,7 @@ static bool remove_test(struct dgraph_node *node, const char *why)
        return true;
 }
 
-static char *exclude_test(const char *testname, void *unused)
+static char *exclude_test(const char *testname, void *unused UNNEEDED)
 {
        struct ccanlint *i = find_test(testname);
        if (!i)
@@ -378,7 +380,7 @@ static void skip_test_and_deps(struct ccanlint *c, const char *why)
        skip_test(&c->node, why);
 }
 
-static char *list_tests(void *arg)
+static char *list_tests(void *arg UNNEEDED)
 {
        struct ccanlint *i;
 
@@ -392,7 +394,8 @@ static char *list_tests(void *arg)
        exit(0);
 }
 
-static bool draw_test(const char *member, struct ccanlint *c, const char *style)
+static bool draw_test(const char *member UNNEEDED,
+                     struct ccanlint *c, const char *style)
 {
        /*
         * todo: escape labels in case ccanlint test keys have
@@ -407,7 +410,8 @@ static void test_dgraph_vertices(const char *style)
        strmap_iterate(&tests, draw_test, style);
 }
 
-static bool draw_edges(const char *member, struct ccanlint *c, void *unused)
+static bool draw_edges(const char *member UNNEEDED,
+                      struct ccanlint *c, void *unused UNNEEDED)
 {
        struct dgraph_edge *e;
 
@@ -425,7 +429,7 @@ static void test_dgraph_edges(void)
        strmap_iterate(&tests, draw_edges, NULL);
 }
 
-static char *test_dependency_graph(void *arg)
+static char *test_dependency_graph(void *arg UNNEEDED)
 {
        puts("digraph G {");
 
@@ -563,7 +567,7 @@ static bool run_tests(struct dgraph_node *all,
        struct run_info run;
        const char *comment = "";
 
-       run.quiet = summary;
+       run.noninteractive = summary;
        run.m = m;
        run.prefix = prefix;
        run.score = run.total = 0;
@@ -586,7 +590,7 @@ static bool run_tests(struct dgraph_node *all,
        return run.pass;
 }
 
-static bool add_to_all(const char *member, struct ccanlint *c,
+static bool add_to_all(const char *member UNNEEDED, struct ccanlint *c,
                       struct dgraph_node *all)
 {
        /* If we're excluded on cmdline, don't add. */
@@ -614,7 +618,7 @@ static bool test_module(struct dgraph_node *all,
 int main(int argc, char *argv[])
 {
        bool summary = false, pass = true, deps_fail_ignore = false;
-       unsigned int i;
+       int i;
        const char *prefix = "";
        char *cwd = path_cwd(NULL), *dir;
        struct ccanlint top;  /* cannot_run may try to set ->can_run */
@@ -634,7 +638,7 @@ int main(int argc, char *argv[])
        opt_register_noarg("-k|--keep", keep_tests, NULL,
                         "do not delete ccanlint working files");
        opt_register_noarg("--summary|-s", opt_set_bool, &summary,
-                          "simply give one line summary");
+                          "give results only, no interactive correction");
        opt_register_arg("-x|--exclude <testname>", exclude_test, NULL, NULL,
                         "exclude <testname> (can be used multiple times)");
        opt_register_arg("--timeout <milleseconds>", opt_set_uintval,

diff --git a/tools/ccanlint/file_analysis.c b/tools/ccanlint/file_analysis.c
index abcf0795e7111dd3c4432332778e398cca05157a..d2fe2a4c1deb621cda477148fa79b4abbe582954 100644 (file)
--- a/tools/ccanlint/file_analysis.c
+++ b/tools/ccanlint/file_analysis.c
@@ -417,7 +417,7 @@ void score_file_error(struct score *score, struct ccan_file *f, unsigned line,
 }
 
 
-char *get_or_compile_info(const void *ctx, const char *dir)
+char *get_or_compile_info(const void *ctx UNNEEDED, const char *dir)
 {
        struct manifest *m = get_manifest(NULL, dir);
 

diff --git a/tools/ccanlint/tests/avoids_cpp_reserved.c b/tools/ccanlint/tests/avoids_cpp_reserved.c
index 78ba6ca8b87fbecdbd7a23db1593d424f537ae22..8e49618023ac814dce9f2faabcede4c077440651 100644 (file)
--- a/tools/ccanlint/tests/avoids_cpp_reserved.c
+++ b/tools/ccanlint/tests/avoids_cpp_reserved.c
@@ -13,7 +13,7 @@
 #include <string.h>
 #include <ctype.h>
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -34,7 +34,8 @@ static struct ccan_file *main_header(struct manifest *m)
 }
 
 static void check_headers_no_cpp(struct manifest *m,
-                                unsigned int *timeleft, struct score *score)
+                                unsigned int *timeleft UNNEEDED,
+                                struct score *score)
 {
        char *contents;
        char *tmpsrc, *tmpobj, *cmdout;

diff --git a/tools/ccanlint/tests/depends_accurate.c b/tools/ccanlint/tests/depends_accurate.c
index 5549fc13360de3f96735a75622b9cd871ef6fa1f..26943faa628a6e98fa93ab5badb9e7c67d511c20 100644 (file)
--- a/tools/ccanlint/tests/depends_accurate.c
+++ b/tools/ccanlint/tests/depends_accurate.c
@@ -70,7 +70,8 @@ static bool check_dep_includes(struct manifest *m,
 }
 
 static void check_depends_accurate(struct manifest *m,
-                                  unsigned int *timeleft, struct score *score)
+                                  unsigned int *timeleft UNNEEDED,
+                                  struct score *score)
 {
        struct list_head *list;
        unsigned int i, core_deps, test_deps;

diff --git a/tools/ccanlint/tests/depends_build.c b/tools/ccanlint/tests/depends_build.c
index d4ebcb1da9af945ddf5652afdcda76d185eb8b0c..24fb7ca3d68de7e281a8cdfdac123d19ea423958 100644 (file)
--- a/tools/ccanlint/tests/depends_build.c
+++ b/tools/ccanlint/tests/depends_build.c
@@ -15,7 +15,7 @@
 #include <ctype.h>
 #include "build.h"
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -76,7 +76,8 @@ char *build_submodule(struct manifest *m, const char *flags,
 }
 
 static void check_depends_built(struct manifest *m,
-                               unsigned int *timeleft, struct score *score)
+                               unsigned int *timeleft UNNEEDED,
+                               struct score *score)
 {
        struct list_head *list;
 

diff --git a/tools/ccanlint/tests/depends_build_without_features.c b/tools/ccanlint/tests/depends_build_without_features.c
index f9f582aff79aada824d8d05465634b20506fd136..cacb5002532c8f8f0e8b39c4d7bb39956f722c57 100644 (file)
--- a/tools/ccanlint/tests/depends_build_without_features.c
+++ b/tools/ccanlint/tests/depends_build_without_features.c
@@ -16,7 +16,7 @@
 #include "reduce_features.h"
 #include "build.h"
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -24,7 +24,7 @@ static const char *can_build(struct manifest *m)
 }
 
 static void check_depends_built_without_features(struct manifest *m,
-                                                unsigned int *timeleft,
+                                                unsigned int *timeleft UNNEEDED,
                                                 struct score *score)
 {
        struct list_head *list;

diff --git a/tools/ccanlint/tests/depends_exist.c b/tools/ccanlint/tests/depends_exist.c
index 088b1e0cd6472a702bd974c1051b7770eb1b0597..50f154221f3bb46e931da8d845b768a9c4f025b7 100644 (file)
--- a/tools/ccanlint/tests/depends_exist.c
+++ b/tools/ccanlint/tests/depends_exist.c
@@ -46,7 +46,8 @@ static bool add_dep(struct manifest *m,
 
 /* FIXME: check this is still true once we reduce features. */
 static void check_depends_exist(struct manifest *m,
-                               unsigned int *timeleft, struct score *score)
+                               unsigned int *timeleft UNNEEDED,
+                               struct score *score)
 {
        unsigned int i;
        char **deps;
@@ -77,7 +78,7 @@ static void check_depends_exist(struct manifest *m,
 }
 
 static void check_test_depends_exist(struct manifest *m,
-                                    unsigned int *timeleft,
+                                    unsigned int *timeleft UNNEEDED,
                                     struct score *score)
 {
        unsigned int i;

diff --git a/tools/ccanlint/tests/examples_compile.c b/tools/ccanlint/tests/examples_compile.c
index 745860668beddc8e158d3d5226dc3a4d0b4b849b..5086239396840d524c9c4df2a3c613bb96bd14ca 100644 (file)
--- a/tools/ccanlint/tests/examples_compile.c
+++ b/tools/ccanlint/tests/examples_compile.c
@@ -359,7 +359,8 @@ static char *strip_comment(const void *ctx, const char *orig_line)
 static char *mangle(struct manifest *m, char **lines)
 {
        char *ret, *use_funcs = NULL, *why;
-       bool in_function = false, fake_function = false, has_main = false;
+       bool in_function = false, fake_function = false, has_main = false,
+               fake_main = false;
        unsigned int i;
 
        ret = tal_fmt(m,
@@ -393,6 +394,7 @@ static char *mangle(struct manifest *m, char **lines)
                fake_function = true;
                in_function = true;
                has_main = true;
+               fake_main = true;
        } else
                tal_append_fmt(&ret,
                             "/* The example %s, so didn't wrap in main() */\n",
@@ -429,6 +431,7 @@ static char *mangle(struct manifest *m, char **lines)
                                /* This implies we start a function here. */
                                start_main(&ret, why);
                                has_main = true;
+                               fake_main = true;
                                fake_function = true;
                                in_function = true;
                        }
@@ -442,8 +445,9 @@ static char *mangle(struct manifest *m, char **lines)
        if (!has_main) {
                ret = tal_strcat(m, take(ret),
                             "/* Need a main to link successfully. */\n"
-                            "int main(void)\n{\n");
+                            "int main(int argc, char *argv[])\n{\n");
                fake_function = true;
+               fake_main = true;
        }
 
        if (use_funcs) {
@@ -460,8 +464,13 @@ static char *mangle(struct manifest *m, char **lines)
                tal_append_fmt(&ret, "  %s\n", use_funcs);
        }
 
+       if (fake_main)
+               ret = tal_strcat(m, take(ret),
+                                "(void)argc; (void)argv;\n");
+       
        if (fake_function)
-               ret = tal_strcat(m, take(ret), "return 0;\n}\n");
+               ret = tal_strcat(m, take(ret),
+                                "return 0;\n}\n");
        return ret;
 }
 
@@ -485,7 +494,7 @@ static struct ccan_file *mangle_example(struct manifest *m,
                return NULL;
 
        contents = mangle(m, lines);
-       if (write(fd, contents, strlen(contents)) != strlen(contents)) {
+       if (write(fd, contents, strlen(contents)) != (int)strlen(contents)) {
                close(fd);
                return NULL;
        }
@@ -550,7 +559,7 @@ static unsigned int try_compiling(struct manifest *m,
 }
 
 static void build_examples(struct manifest *m,
-                          unsigned int *timeleft, struct score *score)
+                          unsigned int *timeleft UNNEEDED, struct score *score)
 {
        struct ccan_file *i;
        char **prev = NULL;

diff --git a/tools/ccanlint/tests/examples_exist.c b/tools/ccanlint/tests/examples_exist.c
index c42a2e4e9ff27c5f183b498e798c3ae10a1e238f..61359596e1f693ed56a127c613724462e1f1f2d7 100644 (file)
--- a/tools/ccanlint/tests/examples_exist.c
+++ b/tools/ccanlint/tests/examples_exist.c
@@ -45,7 +45,10 @@ static char *add_example(struct manifest *m, struct ccan_file *source,
        /* Add #line to demark where we are from, so errors are correct! */
        linemarker = tal_fmt(f, "#line %i \"%s\"\n",
                             example->srcline+2, source->fullname);
-       write(fd, linemarker, strlen(linemarker));
+       if (write(fd, linemarker, strlen(linemarker)) != (int)strlen(linemarker)) {
+               close(fd);
+               return cast_const(char *, "Failure writing to temporary file");
+       }
 
        for (i = 0; i < example->num_lines; i++) {
                if (write(fd, example->lines[i], strlen(example->lines[i]))
@@ -62,7 +65,7 @@ static char *add_example(struct manifest *m, struct ccan_file *source,
 
 /* FIXME: We should have one example per function in header. */
 static void extract_examples(struct manifest *m,
-                            unsigned int *timeleft,
+                            unsigned int *timeleft UNNEEDED,
                             struct score *score)
 {
        struct ccan_file *f, *mainh = NULL; /* gcc complains uninitialized */

diff --git a/tools/ccanlint/tests/examples_relevant.c b/tools/ccanlint/tests/examples_relevant.c
index ad718db3a54cf5a566d677f8e24e265082b58560..1fc1f3bb67a21fe795916f91fa00e8f9543eb223 100644 (file)
--- a/tools/ccanlint/tests/examples_relevant.c
+++ b/tools/ccanlint/tests/examples_relevant.c
@@ -14,7 +14,7 @@
 #include <ctype.h>
 
 static void examples_relevant_check(struct manifest *m,
-                                   unsigned int *timeleft,
+                                   unsigned int *timeleft UNNEEDED,
                                    struct score *score)
 {
        struct ccan_file *f;

diff --git a/tools/ccanlint/tests/examples_run.c b/tools/ccanlint/tests/examples_run.c
index 8ea6a9bf515806fa58e22bbe480c96e8b4065460..6c746b64a3722f362b6908f59abd4f39f1c5a5a5 100644 (file)
--- a/tools/ccanlint/tests/examples_run.c
+++ b/tools/ccanlint/tests/examples_run.c
@@ -188,7 +188,7 @@ static char *unexpected(struct ccan_file *i, const char *input,
 }
 
 static void run_examples(struct manifest *m,
-                        unsigned int *timeleft, struct score *score)
+                        unsigned int *timeleft UNNEEDED, struct score *score)
 {
        struct ccan_file *i;
        struct list_head *list;

diff --git a/tools/ccanlint/tests/hash_if.c b/tools/ccanlint/tests/hash_if.c
index 78b8a9674e484dd26b3ca4b19a75ae325fcfc488..e647ca2190aa4e25978ff0e4f4b608036156672d 100644 (file)
--- a/tools/ccanlint/tests/hash_if.c
+++ b/tools/ccanlint/tests/hash_if.c
@@ -15,7 +15,8 @@
 #include <ctype.h>
 
 static void check_hash_if(struct manifest *m,
-                         unsigned int *timeleft, struct score *score)
+                         unsigned int *timeleft UNNEEDED,
+                         struct score *score)
 {
        struct list_head *list;
        const char *explanation =

diff --git a/tools/ccanlint/tests/headers_idempotent.c b/tools/ccanlint/tests/headers_idempotent.c
index 1b2916bda3cb1ec1293ba59f7cda7f4b5ea6f8c8..56c37ef7cbb59489d771d41d7b5f6562359a90b9 100644 (file)
--- a/tools/ccanlint/tests/headers_idempotent.c
+++ b/tools/ccanlint/tests/headers_idempotent.c
@@ -178,7 +178,8 @@ static void check_idem(struct ccan_file *f, struct score *score)
 }
 
 static void check_idempotent(struct manifest *m,
-                            unsigned int *timeleft, struct score *score)
+                            unsigned int *timeleft UNNEEDED,
+                            struct score *score)
 {
        struct ccan_file *f;
 

diff --git a/tools/ccanlint/tests/info_compiles.c b/tools/ccanlint/tests/info_compiles.c
index 4ec07a0e0486b916c568c0d421f9161e86b5be9b..e1485963e8fbb479be8aac8da0c9c098fb923695 100644 (file)
--- a/tools/ccanlint/tests/info_compiles.c
+++ b/tools/ccanlint/tests/info_compiles.c
@@ -16,7 +16,8 @@
 #include <ctype.h>
 
 static void check_info_compiles(struct manifest *m,
-                               unsigned int *timeleft, struct score *score)
+                               unsigned int *timeleft UNNEEDED,
+                               struct score *score)
 {
        char *info_c_file, *info, *output;
        int fd;

diff --git a/tools/ccanlint/tests/info_documentation_exists.c b/tools/ccanlint/tests/info_documentation_exists.c
index 47e72e5777edcb9824f5a5c069678285054ea872..c3f02226b869b5182c8fe49a76a9133c98bc9ddf 100644 (file)
--- a/tools/ccanlint/tests/info_documentation_exists.c
+++ b/tools/ccanlint/tests/info_documentation_exists.c
@@ -25,7 +25,8 @@ static struct ccanlint info_documentation_exists = {
        .needs = "info_exists"
 };
 
-static void create_info_template_doc(struct manifest *m, struct score *score)
+static void create_info_template_doc(struct manifest *m,
+                                    struct score *score UNNEEDED)
 {
        int fd;
        FILE *new;
@@ -71,7 +72,7 @@ static void create_info_template_doc(struct manifest *m, struct score *score)
 }
 
 static void check_info_documentation_exists(struct manifest *m,
-                                           unsigned int *timeleft,
+                                           unsigned int *timeleft UNNEEDED,
                                            struct score *score)
 {
        struct list_head *infodocs = get_ccan_file_docs(m->info_file);

diff --git a/tools/ccanlint/tests/info_exists.c b/tools/ccanlint/tests/info_exists.c
index 9f6f2066ddf90dc5d0149f68ee62827ae7d2f3cd..5e4459bcbe02d362213bcf35e99a33c37c14f175 100644 (file)
--- a/tools/ccanlint/tests/info_exists.c
+++ b/tools/ccanlint/tests/info_exists.c
@@ -14,7 +14,7 @@
 #include <ccan/noerr/noerr.h>
 
 static void check_has_info(struct manifest *m,
-                          unsigned int *timeleft,
+                          unsigned int *timeleft UNNEEDED,
                           struct score *score)
 {
        if (m->info_file) {
@@ -57,7 +57,8 @@ static const char template[] =
        "       return 1;\n"
        "}\n";
 
-static void create_info_template(struct manifest *m, struct score *score)
+static void create_info_template(struct manifest *m,
+                                struct score *score UNNEEDED)
 {
        FILE *info;
        const char *filename;

diff --git a/tools/ccanlint/tests/info_ported.c b/tools/ccanlint/tests/info_ported.c
index 3479cfc417291781c81b47d22f0770f87e7957b0..80e347c73343df3983a4513a4fe1b73b56ed59b4 100644 (file)
--- a/tools/ccanlint/tests/info_ported.c
+++ b/tools/ccanlint/tests/info_ported.c
@@ -27,8 +27,9 @@ static const char *can_build(struct manifest *m)
        return tal_fmt(m, "'_info ported' says '%s'", msg);
 }
 
-static void check_info_ported(struct manifest *m,
-                             unsigned int *timeleft, struct score *score)
+static void check_info_ported(struct manifest *m UNNEEDED,
+                             unsigned int *timeleft UNNEEDED,
+                             struct score *score)
 {
        score->pass = true;
        score->score = 1;

diff --git a/tools/ccanlint/tests/info_summary_single_line.c b/tools/ccanlint/tests/info_summary_single_line.c
index 760c80b31c23810f659a952380516db1abd6eae2..b45e00bab4344c6dcf2f2c0220b133335e564131 100644 (file)
--- a/tools/ccanlint/tests/info_summary_single_line.c
+++ b/tools/ccanlint/tests/info_summary_single_line.c
@@ -4,7 +4,7 @@
 #include <ccan/str/str.h>
 
 static void check_info_summary_single_line(struct manifest *m,
-                                          unsigned int *timeleft,
+                                          unsigned int *timeleft UNNEEDED,
                                           struct score *score)
 {
        struct list_head *infodocs = get_ccan_file_docs(m->info_file);

diff --git a/tools/ccanlint/tests/license_comment.c b/tools/ccanlint/tests/license_comment.c
index abe0204e9c32c2ea9aa7d0142d243d4585a57ee9..ef865a4d6f74fdaa51fe277dae1324e791b3513b 100644 (file)
--- a/tools/ccanlint/tests/license_comment.c
+++ b/tools/ccanlint/tests/license_comment.c
@@ -36,7 +36,8 @@ static bool line_has_license_flavour(const char *line, const char *shortname)
 }
 
 static void check_license_comment(struct manifest *m,
-                                 unsigned int *timeleft, struct score *score)
+                                 unsigned int *timeleft UNNEEDED,
+                                 struct score *score)
 {
        struct list_head *list;
 

diff --git a/tools/ccanlint/tests/license_depends_compat.c b/tools/ccanlint/tests/license_depends_compat.c
index 10858d9ba5a23c4f7a7ee7104abb8113f0cbfb2b..4e73858f1c6146ed39e786e8f06aedb1b6526f81 100644 (file)
--- a/tools/ccanlint/tests/license_depends_compat.c
+++ b/tools/ccanlint/tests/license_depends_compat.c
@@ -11,7 +11,7 @@
 #include <err.h>
 
 static void check_license_depends_compat(struct manifest *m,
-                                        unsigned int *timeleft,
+                                        unsigned int *timeleft UNNEEDED,
                                         struct score *score)
 {
        struct manifest *i;

diff --git a/tools/ccanlint/tests/license_exists.c b/tools/ccanlint/tests/license_exists.c
index 85ff79854082a096756f037ec1b415de4ee50cdd..3482bfee7745d6913a76380e8648a18695e62d65 100644 (file)
--- a/tools/ccanlint/tests/license_exists.c
+++ b/tools/ccanlint/tests/license_exists.c
@@ -94,7 +94,8 @@ static void handle_license_link(struct manifest *m, struct score *score)
 extern struct ccanlint license_exists;
 
 static void check_has_license(struct manifest *m,
-                             unsigned int *timeleft, struct score *score)
+                             unsigned int *timeleft UNNEEDED,
+                             struct score *score)
 {
        char buf[PATH_MAX];
        ssize_t len;

diff --git a/tools/ccanlint/tests/license_file_compat.c b/tools/ccanlint/tests/license_file_compat.c
index 08cc31b9a1b2ddd66fbfe76f89b69b19d60b95fc..e9273d2443372cab2bd04d642300788cede5515d 100644 (file)
--- a/tools/ccanlint/tests/license_file_compat.c
+++ b/tools/ccanlint/tests/license_file_compat.c
@@ -12,7 +12,7 @@
 #include <ccan/str/str.h>
 
 static void check_license_file_compat(struct manifest *m,
-                                     unsigned int *timeleft,
+                                     unsigned int *timeleft UNNEEDED,
                                      struct score *score)
 {
        struct list_head *list;

diff --git a/tools/ccanlint/tests/main_header_compiles.c b/tools/ccanlint/tests/main_header_compiles.c
index f54c6173a53578e76c6e805cf281ef7319a6c19a..1b741d4fd7c5c4b7aa0d77694023f42d4db04f35 100644 (file)
--- a/tools/ccanlint/tests/main_header_compiles.c
+++ b/tools/ccanlint/tests/main_header_compiles.c
@@ -13,7 +13,7 @@
 #include <string.h>
 #include <ctype.h>
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -34,7 +34,8 @@ static struct ccan_file *main_header(struct manifest *m)
 }
 
 static void check_includes_build(struct manifest *m,
-                                unsigned int *timeleft, struct score *score)
+                                unsigned int *timeleft UNNEEDED,
+                                struct score *score)
 {
        char *contents;
        char *tmpsrc, *tmpobj, *cmdout;

diff --git a/tools/ccanlint/tests/main_header_exists.c b/tools/ccanlint/tests/main_header_exists.c
index 2af9afc00892a7561fdf92f6b514f777ef78c0b5..52a7e43c52b169dd7c3689dfafedfddf99c95a7d 100644 (file)
--- a/tools/ccanlint/tests/main_header_exists.c
+++ b/tools/ccanlint/tests/main_header_exists.c
@@ -14,7 +14,8 @@
 #include <ccan/noerr/noerr.h>
 
 static void check_has_main_header(struct manifest *m,
-                                 unsigned int *timeleft, struct score *score)
+                                 unsigned int *timeleft UNNEEDED,
+                                 struct score *score)
 {
        struct ccan_file *f;
 

diff --git a/tools/ccanlint/tests/module_builds.c b/tools/ccanlint/tests/module_builds.c
index cb13a0b63e6a53933705d9e3370f9237d8243238..c33971e60de35906eab8bebf40dbba1610cb8b97 100644 (file)
--- a/tools/ccanlint/tests/module_builds.c
+++ b/tools/ccanlint/tests/module_builds.c
@@ -15,7 +15,7 @@
 #include <ctype.h>
 #include "build.h"
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -42,7 +42,7 @@ char *build_module(struct manifest *m,
 }
 
 static void do_build(struct manifest *m,
-                    unsigned int *timeleft,
+                    unsigned int *timeleft UNNEEDED,
                     struct score *score)
 {
        char *errstr;

diff --git a/tools/ccanlint/tests/module_links.c b/tools/ccanlint/tests/module_links.c
index 403fff1a56120d31926359ca64af51afd3480732..9a2c0be5b4ccf2b36a59227f7c757c2477b41487 100644 (file)
--- a/tools/ccanlint/tests/module_links.c
+++ b/tools/ccanlint/tests/module_links.c
@@ -14,7 +14,7 @@
 #include <string.h>
 #include <ctype.h>
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -65,7 +65,8 @@ static char *lib_list(const struct manifest *m)
 }
 
 static void check_use_build(struct manifest *m,
-                           unsigned int *timeleft, struct score *score)
+                           unsigned int *timeleft UNNEEDED,
+                           struct score *score)
 {
        char *contents;
        char *tmpfile, *cmdout;

diff --git a/tools/ccanlint/tests/no_trailing_whitespace.c b/tools/ccanlint/tests/no_trailing_whitespace.c
index 60ecee7962aae030b6570af27790b2a4c67ff7fd..74f759e7b30c2189e465c920046751ebf356fe3c 100644 (file)
--- a/tools/ccanlint/tests/no_trailing_whitespace.c
+++ b/tools/ccanlint/tests/no_trailing_whitespace.c
@@ -21,7 +21,7 @@ static char *get_trailing_whitespace(const tal_t *ctx, const char *line)
 }
 
 static void check_trailing_whitespace(struct manifest *m,
-                                     unsigned int *timeleft,
+                                     unsigned int *timeleft UNNEEDED,
                                      struct score *score)
 {
        struct list_head *list;

diff --git a/tools/ccanlint/tests/objects_build.c b/tools/ccanlint/tests/objects_build.c
index d0bd7365dc7c52024975626c0e950a2a6e1d8e87..58f364373a5f63b5624cd0a55bf39d65bbcd931c 100644 (file)
--- a/tools/ccanlint/tests/objects_build.c
+++ b/tools/ccanlint/tests/objects_build.c
@@ -15,7 +15,7 @@
 #include <ctype.h>
 #include "build.h"
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -74,7 +74,8 @@ void build_objects(struct manifest *m,
 }
 
 static void check_objs_build(struct manifest *m,
-                            unsigned int *timeleft, struct score *score)
+                            unsigned int *timeleft UNNEEDED,
+                            struct score *score)
 {
        const char *flags;
 

diff --git a/tools/ccanlint/tests/objects_build_with_stringchecks.c b/tools/ccanlint/tests/objects_build_with_stringchecks.c
index 1e99c100c1ce8725b4964d0e66b0d1f10c173854..083e7923ac8fca2ca34d39dfa960bb2209dc8fd2 100644 (file)
--- a/tools/ccanlint/tests/objects_build_with_stringchecks.c
+++ b/tools/ccanlint/tests/objects_build_with_stringchecks.c
@@ -92,7 +92,7 @@ static struct ccan_file *get_main_header(struct manifest *m)
 }
 
 static void build_objects_with_stringchecks(struct manifest *m,
-                                           unsigned int *timeleft,
+                                           unsigned int *timeleft UNNEEDED,
                                            struct score *score)
 {
        struct ccan_file *i;

diff --git a/tools/ccanlint/tests/objects_build_without_features.c b/tools/ccanlint/tests/objects_build_without_features.c
index 4406842fd984d88fd802aee32e41c71f4ccf99e1..a32c0f6248346f1c63b7c643450a2c278e51f16f 100644 (file)
--- a/tools/ccanlint/tests/objects_build_without_features.c
+++ b/tools/ccanlint/tests/objects_build_without_features.c
@@ -4,7 +4,7 @@
 #include "build.h"
 
 static void check_objs_build_without_features(struct manifest *m,
-                                             unsigned int *timeleft,
+                                             unsigned int *timeleft UNNEEDED,
                                              struct score *score)
 {
        const char *flags = tal_fmt(score, "%s %s",

diff --git a/tools/ccanlint/tests/reduce_features.c b/tools/ccanlint/tests/reduce_features.c
index b46c85fcfef081c685c74f673436f12d39e9ab28..b49922b5d11b27b310b0b843870ee2be8310ed4a 100644 (file)
--- a/tools/ccanlint/tests/reduce_features.c
+++ b/tools/ccanlint/tests/reduce_features.c
@@ -130,7 +130,8 @@ static struct htable_option *get_config_options(struct manifest *m)
 }
 
 static void do_reduce_features(struct manifest *m,
-                              unsigned int *timeleft, struct score *score)
+                              unsigned int *timeleft UNNEEDED,
+                              struct score *score)
 {
        struct htable_option *options_used, *options_avail, *options;
        struct htable_option_iter i;

diff --git a/tools/ccanlint/tests/tests_compile.c b/tools/ccanlint/tests/tests_compile.c
index f6995085c4f08d42ebe9a5c2feb9037a676f08c4..0bafcc64e5ddb6124d956eb265c24fe62eff7ce9 100644 (file)
--- a/tools/ccanlint/tests/tests_compile.c
+++ b/tools/ccanlint/tests/tests_compile.c
@@ -16,7 +16,7 @@
 #include "reduce_features.h"
 #include "tests_compile.h"
 
-static const char *can_build(struct manifest *m)
+static const char *can_build(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -54,7 +54,7 @@ char *test_obj_list(const struct manifest *m, bool link_with_module,
        return list;
 }
 
-char *test_lib_list(const struct manifest *m, enum compile_type ctype)
+char *test_lib_list(const struct manifest *m, enum compile_type ctype UNNEEDED)
 {
        unsigned int i;
        char **libs;
@@ -211,7 +211,7 @@ struct ccanlint tests_compile = {
 
 REGISTER_TEST(tests_compile);
 
-static const char *features_reduced(struct manifest *m)
+static const char *features_reduced(struct manifest *m UNNEEDED)
 {
        if (features_were_reduced)
                return NULL;

diff --git a/tools/ccanlint/tests/tests_exist.c b/tools/ccanlint/tests/tests_exist.c
index 69e01df6e909ee64c0501384dcc25291efe7afa3..24c4d8776ac241265f371767b1a4292e74f353e2 100644 (file)
--- a/tools/ccanlint/tests/tests_exist.c
+++ b/tools/ccanlint/tests/tests_exist.c
@@ -22,7 +22,7 @@ static struct ccanlint tests_exist = {
 };
 REGISTER_TEST(tests_exist);
 
-static void handle_no_tests(struct manifest *m, struct score *score)
+static void handle_no_tests(struct manifest *m, struct score *score UNNEEDED)
 {
        FILE *run;
        struct ccan_file *i;
@@ -104,7 +104,8 @@ static void handle_no_tests(struct manifest *m, struct score *score)
 }
 
 static void check_tests_exist(struct manifest *m,
-                           unsigned int *timeleft, struct score *score)
+                             unsigned int *timeleft UNNEEDED,
+                             struct score *score)
 {
        struct stat st;
        char *test_dir = path_join(m, m->dir, "test");

diff --git a/tools/ccanlint/tests/tests_helpers_compile.c b/tools/ccanlint/tests/tests_helpers_compile.c
index 6384bd38421b3d10cf4a74c0c77a9d974f0a2433..0f728fb9420160b7bf852ce8210289056d59a163 100644 (file)
--- a/tools/ccanlint/tests/tests_helpers_compile.c
+++ b/tools/ccanlint/tests/tests_helpers_compile.c
@@ -14,7 +14,7 @@
 #include <ctype.h>
 #include "reduce_features.h"
 
-static const char *can_run(struct manifest *m)
+static const char *can_run(struct manifest *m UNNEEDED)
 {
        if (safe_mode)
                return "Safe mode enabled";
@@ -33,7 +33,7 @@ static bool compile(struct manifest *m,
 }
 
 static void compile_test_helpers(struct manifest *m,
-                                unsigned int *timeleft,
+                                unsigned int *timeleft UNNEEDED,
                                 struct score *score,
                                 const char *flags,
                                 enum compile_type ctype)
@@ -83,7 +83,7 @@ struct ccanlint tests_helpers_compile = {
 
 REGISTER_TEST(tests_helpers_compile);
 
-static const char *features_reduced(struct manifest *m)
+static const char *features_reduced(struct manifest *m UNNEEDED)
 {
        if (features_were_reduced)
                return NULL;

diff --git a/tools/ccanlint/tests/tests_pass.c b/tools/ccanlint/tests/tests_pass.c
index af71dbe4c9f58cce4cc5da90a8e58da2c84b129b..ba6103de2d50bf118b1952df3e7c28f66f16e7a2 100644 (file)
--- a/tools/ccanlint/tests/tests_pass.c
+++ b/tools/ccanlint/tests/tests_pass.c
@@ -139,8 +139,9 @@ static void run_under_debugger(struct manifest *m, struct score *score)
 
        command = tal_fmt(m, "gdb -ex 'break tap.c:139' -ex 'run' %s",
                          first->file->compiled[COMPILE_NORMAL]);
-       if (system(command))
+       if (system(command)) {
                doesnt_matter();
+       }
 }
 
 struct ccanlint tests_pass = {

diff --git a/tools/ccanlint/tests/tests_pass_valgrind.c b/tools/ccanlint/tests/tests_pass_valgrind.c
index 2f4df18b47e4382a3ea8d7032f78411fece3b536..90e42349715f9ff2c0ef706e54123072f5f52212 100644 (file)
--- a/tools/ccanlint/tests/tests_pass_valgrind.c
+++ b/tools/ccanlint/tests/tests_pass_valgrind.c
@@ -158,7 +158,7 @@ static const char *concat(struct score *score, char *bits[])
 
 /* FIXME: Run examples, too! */
 static void do_run_tests_vg(struct manifest *m,
-                           unsigned int *timeleft,
+                           unsigned int *timeleft UNNEEDED,
                            struct score *score)
 {
        struct ccan_file *i;
@@ -199,7 +199,7 @@ static void do_run_tests_vg(struct manifest *m,
 }
 
 static void do_leakcheck_vg(struct manifest *m,
-                           unsigned int *timeleft,
+                           unsigned int *timeleft UNNEEDED,
                            struct score *score)
 {
        struct ccan_file *i;
@@ -255,8 +255,9 @@ static void run_under_debugger_vg(struct manifest *m, struct score *score)
                          concat(score, per_file_options(&tests_pass_valgrind,
                                                         first->file)),
                          valgrind_suppress, first->file->compiled[COMPILE_NORMAL]);
-       if (system(command))
+       if (system(command)) {
                doesnt_matter();
+       }
 }
 
 struct ccanlint tests_pass_valgrind = {

diff --git a/tools/ccanlint/tests/tests_pass_without_features.c b/tools/ccanlint/tests/tests_pass_without_features.c
index 999c4eda45663dace4fa759dc891e7a5f8ee3c94..15b161ef9c20a06f9e2bbfe22749cddd14ece7ed 100644 (file)
--- a/tools/ccanlint/tests/tests_pass_without_features.c
+++ b/tools/ccanlint/tests/tests_pass_without_features.c
@@ -56,8 +56,9 @@ static void run_under_debugger(struct manifest *m, struct score *score)
 
        command = tal_fmt(m, "gdb -ex 'break tap.c:139' -ex 'run' %s",
                          first->file->compiled[COMPILE_NOFEAT]);
-       if (system(command))
+       if (system(command)) {
                doesnt_matter();
+       }
 }
 
 struct ccanlint tests_pass_without_features = {

diff --git a/tools/compile.c b/tools/compile.c
index b88c1d865186b636e35ee359186517196d80b7ac..e796e3f97a9be24b6c1edd5d8dd43b26ffd2d8dd 100644 (file)
--- a/tools/compile.c
+++ b/tools/compile.c
@@ -7,8 +7,12 @@
 #ifndef CCAN_CFLAGS
 #define CCAN_CFLAGS DEFAULT_CCAN_CFLAGS
 #endif
+#ifndef CCAN_OUTPUT_EXE_CFLAG
+#define CCAN_OUTPUT_EXE_CFLAG DEFAULT_CCAN_OUTPUT_EXE_CFLAG
+#endif
 const char *compiler = CCAN_COMPILER;
 const char *cflags = CCAN_CFLAGS;
+const char *outexecflag = CCAN_OUTPUT_EXE_CFLAG;
 
 bool compile_verbose = false;
 
@@ -37,8 +41,9 @@ bool compile_object(const void *ctx, const char *cfile, const char *ccandir,
        if (compile_verbose)
                printf("Compiling %s\n", outfile);
        return run_command(ctx, NULL, output,
-                          "%s %s -I%s -c -o %s %s",
-                          compiler, cflags, ccandir, outfile, cfile);
+                          "%s %s -I%s -c %s%s %s",
+                          compiler, cflags, ccandir,
+                          outexecflag, outfile, cfile);
 }
 
 /* Compile and link single C file, with object files.
@@ -51,7 +56,7 @@ bool compile_and_link(const void *ctx, const char *cfile, const char *ccandir,
        if (compile_verbose)
                printf("Compiling and linking %s\n", outfile);
        return run_command(ctx, NULL, output,
-                          "%s %s -I%s -o %s %s %s %s",
-                          compiler, cflags,
-                          ccandir, outfile, cfile, objs, libs);
+                          "%s %s -I%s %s%s %s %s %s",
+                          compiler, cflags, ccandir,
+                          outexecflag, outfile, cfile, objs, libs);
 }

diff --git a/tools/configurator/configurator.c b/tools/configurator/configurator.c
index 67dadc61eb8a550cea7c3a86f491458a64647e81..6ec30bd6deb77596fde041983175f4eaa117741d 100644 (file)
--- a/tools/configurator/configurator.c
+++ b/tools/configurator/configurator.c
@@ -3,6 +3,9 @@
  *
  * Copyright 2011 Rusty Russell <rusty@rustcorp.com.au>.  MIT license.
  *
+ * c12r_err, c12r_errx functions copied from ccan/err/err.c
+ * Copyright Rusty Russell <rusty@rustcorp.com.au>. CC0 (Public domain) License.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
@@ -21,23 +24,46 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+#define _POSIX_C_SOURCE 200809L                /* For pclose, popen, strdup */
+
+#include <errno.h>
 #include <stdio.h>
+#include <stdarg.h>
 #include <stdbool.h>
 #include <stdlib.h>
-#include <unistd.h>
-#include <err.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/stat.h>
-#include <fcntl.h>
 #include <string.h>
 
+#ifdef _MSC_VER
+#define popen _popen
+#define pclose _pclose
+#endif
+
+#ifdef _MSC_VER
+#define DEFAULT_COMPILER "cl"
+/* Note:  Dash options avoid POSIX path conversion when used under msys bash
+ *        and are therefore preferred to slash (e.g. -nologo over /nologo)
+ * Note:  Disable Warning 4200 "nonstandard extension used : zero-sized array
+ *        in struct/union" for flexible array members.
+ */
+#define DEFAULT_FLAGS "-nologo -Zi -W4 -wd4200 " \
+       "-D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS"
+#define DEFAULT_OUTPUT_EXE_FLAG "-Fe:"
+#else
 #define DEFAULT_COMPILER "cc"
 #define DEFAULT_FLAGS "-g3 -ggdb -Wall -Wundef -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes -Wold-style-definition"
+#define DEFAULT_OUTPUT_EXE_FLAG "-o"
+#endif
 
 #define OUTPUT_FILE "configurator.out"
 #define INPUT_FILE "configuratortest.c"
 
+#ifdef _WIN32
+#define DIR_SEP   "\\"
+#else
+#define DIR_SEP   "/"
+#endif
+
+static const char *progname = "";
 static int verbose;
 
 enum test_style {
@@ -62,7 +88,7 @@ struct test {
 };
 
 static struct test tests[] = {
-       { "HAVE_32BIT_OFF_T", DEFINES_EVERYTHING|EXECUTE, NULL, NULL,
+       { "HAVE_32BIT_OFF_T", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL,
          "#include <sys/types.h>\n"
          "int main(void) {\n"
          "     return sizeof(off_t) == 4 ? 0 : 1;\n"
@@ -167,7 +193,7 @@ static struct test tests[] = {
        { "HAVE_COMPOUND_LITERALS", INSIDE_MAIN, NULL, NULL,
          "int *foo = (int[]) { 1, 2, 3, 4 };\n"
          "return foo[0] ? 0 : 1;" },
-       { "HAVE_FCHDIR", DEFINES_EVERYTHING|EXECUTE, NULL, NULL,
+       { "HAVE_FCHDIR", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL,
          "#include <sys/types.h>\n"
          "#include <sys/stat.h>\n"
          "#include <fcntl.h>\n"
@@ -188,7 +214,7 @@ static struct test tests[] = {
          "     if (arg == 4)\n"
          "             warnx(\"warn %u\", arg);\n"
          "}\n" },
-       { "HAVE_FILE_OFFSET_BITS", DEFINES_EVERYTHING|EXECUTE,
+       { "HAVE_FILE_OFFSET_BITS", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE,
          "HAVE_32BIT_OFF_T", NULL,
          "#define _FILE_OFFSET_BITS 64\n"
          "#include <sys/types.h>\n"
@@ -196,8 +222,9 @@ static struct test tests[] = {
          "     return sizeof(off_t) == 8 ? 0 : 1;\n"
          "}\n" },
        { "HAVE_FOR_LOOP_DECLARATION", INSIDE_MAIN, NULL, NULL,
-         "for (int i = 0; i < argc; i++) { return 0; };\n"
-         "return 1;" },
+         "int ret = 1;\n"
+         "for (int i = 0; i < argc; i++) { ret = 0; };\n"
+         "return ret;" },
        { "HAVE_FLEXIBLE_ARRAY_MEMBER", OUTSIDE_MAIN, NULL, NULL,
          "struct foo { unsigned int x; int arr[]; };" },
        { "HAVE_GETPAGESIZE", DEFINES_FUNC, NULL, NULL,
@@ -234,7 +261,7 @@ static struct test tests[] = {
          "static void *func(int fd) {\n"
          "     return mmap(0, 65536, PROT_READ, MAP_SHARED, fd, 0);\n"
          "}" },
-       { "HAVE_PROC_SELF_MAPS", DEFINES_EVERYTHING|EXECUTE, NULL, NULL,
+       { "HAVE_PROC_SELF_MAPS", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL,
          "#include <sys/types.h>\n"
          "#include <sys/stat.h>\n"
          "#include <fcntl.h>\n"
@@ -271,7 +298,8 @@ static struct test tests[] = {
          "     return __stop_mysec - __start_mysec;\n"
          "}\n" },
        { "HAVE_STACK_GROWS_UPWARDS", DEFINES_EVERYTHING|EXECUTE, NULL, NULL,
-         "static long nest(const void *base, unsigned int i)\n"
+         "#include <stddef.h>\n"
+         "static ptrdiff_t nest(const void *base, unsigned int i)\n"
          "{\n"
          "     if (i == 0)\n"
          "             return (const char *)&i - (const char *)base;\n"
@@ -319,7 +347,7 @@ static struct test tests[] = {
          "-Werror -fopenmp" },
        { "HAVE_VALGRIND_MEMCHECK_H", OUTSIDE_MAIN, NULL, NULL,
          "#include <valgrind/memcheck.h>\n" },
-       { "HAVE_UCONTEXT", DEFINES_EVERYTHING|EXECUTE,
+       { "HAVE_UCONTEXT", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE,
          NULL, NULL,
          "#include <ucontext.h>\n"
          "static int x = 0;\n"
@@ -340,7 +368,7 @@ static struct test tests[] = {
          "     return (x == 3) ? 0 : 1;\n"
          "}\n"
        },
-       { "HAVE_POINTER_SAFE_MAKECONTEXT", DEFINES_EVERYTHING|EXECUTE,
+       { "HAVE_POINTER_SAFE_MAKECONTEXT", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE,
          "HAVE_UCONTEXT", NULL,
          "#include <stddef.h>\n"
          "#include <ucontext.h>\n"
@@ -367,71 +395,95 @@ static struct test tests[] = {
        },
 };
 
-static char *grab_fd(int fd)
+static void c12r_err(int eval, const char *fmt, ...)
+{
+       int err_errno = errno;
+       va_list ap;
+
+       fprintf(stderr, "%s: ", progname);
+       va_start(ap, fmt);
+       vfprintf(stderr, fmt, ap);
+       va_end(ap);
+       fprintf(stderr, ": %s\n", strerror(err_errno));
+       exit(eval);
+}
+
+static void c12r_errx(int eval, const char *fmt, ...)
 {
-       int ret;
-       size_t max, size = 0;
+       va_list ap;
+
+       fprintf(stderr, "%s: ", progname);
+       va_start(ap, fmt);
+       vfprintf(stderr, fmt, ap);
+       va_end(ap);
+       fprintf(stderr, "\n");
+       exit(eval);
+}
+
+static size_t fcopy(FILE *fsrc, FILE *fdst)
+{
+       char buffer[BUFSIZ];
+       size_t rsize, wsize;
+       size_t copied = 0;
+
+       while ((rsize = fread(buffer, 1, BUFSIZ, fsrc)) > 0) {
+               wsize = fwrite(buffer, 1, rsize, fdst);
+               copied += wsize;
+               if (wsize != rsize)
+                       break;
+       }
+
+       return copied;
+}
+
+static char *grab_stream(FILE *file)
+{
+       size_t max, ret, size = 0;
        char *buffer;
 
-       max = 16384;
-       buffer = malloc(max+1);
-       while ((ret = read(fd, buffer + size, max - size)) > 0) {
+       max = BUFSIZ;
+       buffer = malloc(max);
+       while ((ret = fread(buffer+size, 1, max - size, file)) == max - size) {
                size += ret;
-               if (size == max)
-                       buffer = realloc(buffer, max *= 2);
+               buffer = realloc(buffer, max *= 2);
        }
-       if (ret < 0)
-               err(1, "reading from command");
+       size += ret;
+       if (ferror(file))
+               c12r_err(1, "reading from command");
        buffer[size] = '\0';
        return buffer;
 }
 
 static char *run(const char *cmd, int *exitstatus)
 {
-       pid_t pid;
-       int p[2];
+       static const char redir[] = " 2>&1";
+       size_t cmdlen;
+       char *cmdredir;
+       FILE *cmdout;
        char *ret;
-       int status;
 
-       if (pipe(p) != 0)
-               err(1, "creating pipe");
-
-       pid = fork();
-       if (pid == -1)
-               err(1, "forking");
-
-       if (pid == 0) {
-               if (dup2(p[1], STDOUT_FILENO) != STDOUT_FILENO
-                   || dup2(p[1], STDERR_FILENO) != STDERR_FILENO
-                   || close(p[0]) != 0
-                   || close(STDIN_FILENO) != 0
-                   || open("/dev/null", O_RDONLY) != STDIN_FILENO)
-                       exit(128);
-
-               status = system(cmd);
-               if (WIFEXITED(status))
-                       exit(WEXITSTATUS(status));
-               /* Here's a hint... */
-               exit(128 + WTERMSIG(status));
-       }
+       cmdlen = strlen(cmd);
+       cmdredir = malloc(cmdlen + sizeof(redir));
+       memcpy(cmdredir, cmd, cmdlen);
+       memcpy(cmdredir + cmdlen, redir, sizeof(redir));
+
+       cmdout = popen(cmdredir, "r");
+       if (!cmdout)
+               c12r_err(1, "popen \"%s\"", cmdredir);
 
-       close(p[1]);
-       ret = grab_fd(p[0]);
-       /* This shouldn't fail... */
-       if (waitpid(pid, &status, 0) != pid)
-               err(1, "Failed to wait for child");
-       close(p[0]);
-       if (WIFEXITED(status))
-               *exitstatus = WEXITSTATUS(status);
-       else
-               *exitstatus = -WTERMSIG(status);
+       free(cmdredir);
+
+       ret = grab_stream(cmdout);
+       *exitstatus = pclose(cmdout);
        return ret;
 }
 
-static char *connect_args(const char *argv[], const char *extra)
+static char *connect_args(const char *argv[], const char *outflag,
+               const char *files)
 {
-       unsigned int i, len = strlen(extra) + 1;
+       unsigned int i;
        char *ret;
+       size_t len = strlen(outflag) + strlen(files) + 1;
 
        for (i = 1; argv[i]; i++)
                len += 1 + strlen(argv[i]);
@@ -441,10 +493,12 @@ static char *connect_args(const char *argv[], const char *extra)
        for (i = 1; argv[i]; i++) {
                strcpy(ret + len, argv[i]);
                len += strlen(argv[i]);
-               if (argv[i+1])
+               if (argv[i+1] || *outflag)
                        ret[len++] = ' ';
        }
-       strcpy(ret + len, extra);
+       strcpy(ret + len, outflag);
+       len += strlen(outflag);
+       strcpy(ret + len, files);
        return ret;
 }
 
@@ -483,7 +537,7 @@ static bool run_test(const char *cmd, struct test *test)
                char *dep;
 
                /* Space-separated dependencies, could be ! for inverse. */
-               while ((len = strcspn(deps, " "))) {
+               while ((len = strcspn(deps, " ")) != 0) {
                        bool positive = true;
                        if (deps[len]) {
                                dep = strdup(deps);
@@ -509,9 +563,9 @@ static bool run_test(const char *cmd, struct test *test)
                }
        }
 
-       outf = fopen(INPUT_FILE, "w");
+       outf = fopen(INPUT_FILE, verbose > 1 ? "w+" : "w");
        if (!outf)
-               err(1, "creating %s", INPUT_FILE);
+               c12r_err(1, "creating %s", INPUT_FILE);
 
        fprintf(outf, "%s", PRE_BOILERPLATE);
        switch (test->style & ~(EXECUTE|MAY_NOT_COMPILE)) {
@@ -540,11 +594,13 @@ static bool run_test(const char *cmd, struct test *test)
                abort();
 
        }
-       fclose(outf);
 
-       if (verbose > 1)
-               if (system("cat " INPUT_FILE) == -1)
-                       ;
+       if (verbose > 1) {
+               fseek(outf, 0, SEEK_SET);
+               fcopy(outf, stdout);
+       }
+
+       fclose(outf);
 
        newcmd = strdup(cmd);
 
@@ -576,8 +632,8 @@ static bool run_test(const char *cmd, struct test *test)
                               status ? "fail" : "warning",
                               test->name, status, output);
                if ((test->style & EXECUTE) && !(test->style & MAY_NOT_COMPILE))
-                       errx(1, "Test for %s did not compile:\n%s",
-                            test->name, output);
+                       c12r_errx(1, "Test for %s did not compile:\n%s",
+                                 test->name, output);
                test->answer = false;
                free(output);
        } else {
@@ -585,10 +641,10 @@ static bool run_test(const char *cmd, struct test *test)
                free(output);
                /* We run INSIDE_MAIN tests for sanity checking. */
                if ((test->style & EXECUTE) || (test->style & INSIDE_MAIN)) {
-                       output = run("./" OUTPUT_FILE, &status);
+                       output = run("." DIR_SEP OUTPUT_FILE, &status);
                        if (!(test->style & EXECUTE) && status != 0)
-                               errx(1, "Test for %s failed with %i:\n%s",
-                                    test->name, status, output);
+                               c12r_errx(1, "Test for %s failed with %i:\n%s",
+                                         test->name, status, output);
                        if (verbose && status)
                                printf("%s exited %i\n", test->name, status);
                        free(output);
@@ -611,36 +667,53 @@ int main(int argc, const char *argv[])
        unsigned int i;
        const char *default_args[]
                = { "", DEFAULT_COMPILER, DEFAULT_FLAGS, NULL };
+       const char *outflag = DEFAULT_OUTPUT_EXE_FLAG;
+
+       if (argc > 0)
+               progname = argv[0];
 
-       if (argc > 1) {
+       while (argc > 1) {
                if (strcmp(argv[1], "--help") == 0) {
-                       printf("Usage: configurator [-v] [<compiler> <flags>...]\n"
-                              "  <compiler> <flags> will have \"-o <outfile> <infile.c>\" appended\n"
-                              "Default: %s %s\n",
-                              DEFAULT_COMPILER, DEFAULT_FLAGS);
+                       printf("Usage: configurator [-v] [-O<outflag>] [<compiler> <flags>...]\n"
+                              "  <compiler> <flags> will have \"<outflag> <outfile> <infile.c>\" appended\n"
+                              "Default: %s %s %s\n",
+                              DEFAULT_COMPILER, DEFAULT_FLAGS,
+                              DEFAULT_OUTPUT_EXE_FLAG);
                        exit(0);
                }
-               if (strcmp(argv[1], "-v") == 0) {
+               if (strncmp(argv[1], "-O", 2) == 0) {
+                       argc--;
+                       argv++;
+                       outflag = argv[1] + 2;
+                       if (!*outflag) {
+                               fprintf(stderr,
+                                       "%s: option requires an argument -- O\n",
+                                       argv[0]);
+                               exit(1);
+                       }
+               } else if (strcmp(argv[1], "-v") == 0) {
                        argc--;
                        argv++;
-                       verbose = 1;
+                       verbose++;
                } else if (strcmp(argv[1], "-vv") == 0) {
                        argc--;
                        argv++;
-                       verbose = 2;
+                       verbose += 2;
+               } else {
+                       break;
                }
        }
 
        if (argc == 1)
                argv = default_args;
 
-       cmd = connect_args(argv, " -o " OUTPUT_FILE " " INPUT_FILE);
+       cmd = connect_args(argv, outflag, OUTPUT_FILE " " INPUT_FILE);
        for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
                run_test(cmd, &tests[i]);
        free(cmd);
 
-       unlink(OUTPUT_FILE);
-       unlink(INPUT_FILE);
+       remove(OUTPUT_FILE);
+       remove(INPUT_FILE);
 
        printf("/* Generated by CCAN configurator */\n"
               "#ifndef CCAN_CONFIG_H\n"
@@ -649,9 +722,10 @@ int main(int argc, const char *argv[])
        printf("#define _GNU_SOURCE /* Always use GNU extensions. */\n");
        printf("#endif\n");
        printf("#define CCAN_COMPILER \"%s\"\n", argv[1]);
-       cmd = connect_args(argv+1, "");
-       printf("#define CCAN_CFLAGS \"%s\"\n\n", cmd);
+       cmd = connect_args(argv + 1, "", "");
+       printf("#define CCAN_CFLAGS \"%s\"\n", cmd);
        free(cmd);
+       printf("#define CCAN_OUTPUT_EXE_CFLAG \"%s\"\n\n", outflag);
        /* This one implies "#include <ccan/..." works, eg. for tdb2.h */
        printf("#define HAVE_CCAN 1\n");
        for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)

diff --git a/tools/doc_extract-core.c b/tools/doc_extract-core.c
index 069bf2237c6815f12f428e272970ad863c4b9188..0d6af31737a7ee0e77d56c3059297438e28e2667 100644 (file)
--- a/tools/doc_extract-core.c
+++ b/tools/doc_extract-core.c
@@ -46,7 +46,7 @@ static char **grab_doc(char **lines, unsigned int **linemap,
                                        warnx("%s:%u:"
                                              " Expected ' *' in comment.",
                                              file, i+1);
-                                       warned++;
+                                       warned = true;
                                }
                                ret[num++] = tal_strdup(ret, lines[i]);
                                if (strstr(lines[i], "*/"))

diff --git a/tools/manifest.c b/tools/manifest.c
index 3494937a4009b1b7dad69eb9efe268e9e44fe1ad..82668acfed05fd43eab6b59c7d61dba4f258652f 100644 (file)
--- a/tools/manifest.c
+++ b/tools/manifest.c
@@ -183,7 +183,7 @@ static void add_files(struct manifest *m, const char *base, const char *subdir)
 }
 
 static int cmp_names(struct ccan_file *const *a, struct ccan_file *const *b,
-                    void *unused)
+                    void *unused UNNEEDED)
 {
        return strcmp((*a)->name, (*b)->name);
 }

diff --git a/tools/tools.h b/tools/tools.h
index 3b5c4bed4fcc254e00630ced9804af3553077674..668c91ad1bca8a2042104eee49458e677cd2e17f 100644 (file)
--- a/tools/tools.h
+++ b/tools/tools.h
@@ -11,6 +11,7 @@
 /* These are the defaults. */
 #define DEFAULT_CCAN_COMPILER "cc"
 #define DEFAULT_CCAN_CFLAGS "-g"
+#define DEFAULT_CCAN_OUTPUT_EXE_CFLAG "-o"
 
 #define IDENT_CHARS    "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
                        "abcdefghijklmnopqrstuvwxyz" \
@@ -20,8 +21,9 @@
 
 #define COVERAGE_CFLAGS "-fprofile-arcs -ftest-coverage"
 
-/* Actual compiler and cflags (defaults to CCAN_COMPILER and CCAN_CFLAGS). */
-extern const char *compiler, *cflags;
+/* Actual compiler and cflags
+ * (defaults to CCAN_COMPILER, CCAN_CFLAGS, CCAN_OUTPUT_EXE_CFLAG). */
+extern const char *compiler, *cflags, *outexecflag;
 
 /* This compiles up the _info file into a temporary. */
 char *compile_info(const void *ctx, const char *dir);