From 08dac1288246b1fc9efe1695fe4c7575103e4a2b Mon Sep 17 00:00:00 2001 From: Rusty Russell Date: Tue, 19 May 2015 16:29:54 +0930 Subject: [PATCH] timer: fix two corruption bugs. We fill the upper buckets after we've moved on from the first bucket in this layer. This means two things: 1) If we have to look at an upper layer, we need to look at the next bucket, unless offset is 0. 2) We need to keep looking up layers in the corner case, too. Signed-off-by: Rusty Russell --- ccan/timer/test/run-corrupt.c | 74 + ccan/timer/test/run-original-corrupt.c | 4332 ++++++++++++++++++++++++ ccan/timer/timer.c | 19 +- 3 files changed, 4422 insertions(+), 3 deletions(-) create mode 100644 ccan/timer/test/run-corrupt.c create mode 100644 ccan/timer/test/run-original-corrupt.c diff --git a/ccan/timer/test/run-corrupt.c b/ccan/timer/test/run-corrupt.c new file mode 100644 index 00000000..ee966048 --- /dev/null +++ b/ccan/timer/test/run-corrupt.c @@ -0,0 +1,74 @@ +#define CCAN_TIMER_DEBUG 1 +#include +/* Include the C files directly. */ +#include +#include + +static void new_timer(struct timers *timers, unsigned long nsec) +{ + struct timer *timer; + struct timeabs when; + + timer = malloc(sizeof(*timer)); + timer_init(timer); + when.ts.tv_sec = 0; when.ts.tv_nsec = nsec; + timer_add(timers, timer, when); +} + +static void update_and_expire(struct timers *timers) +{ + struct timeabs when; + + timer_earliest(timers, &when); + free(timers_expire(timers, when)); +} + +int main(int argc, char *argv[]) +{ + struct timeabs when; + struct timers timers; + + plan_tests(7); + + when.ts.tv_sec = 0; when.ts.tv_nsec = 0; + timers_init(&timers, when); + + /* Add these */ + new_timer(&timers, 35000000); + new_timer(&timers, 38000000); + new_timer(&timers, 59000000); + new_timer(&timers, 65000000); + new_timer(&timers, 88000000); + new_timer(&timers, 125000000); + new_timer(&timers, 130000000); + new_timer(&timers, 152000000); + new_timer(&timers, 168000000); + /* Expire all but the last one. */ + update_and_expire(&timers); + update_and_expire(&timers); + update_and_expire(&timers); + update_and_expire(&timers); + update_and_expire(&timers); + update_and_expire(&timers); + update_and_expire(&timers); + update_and_expire(&timers); + /* Add a new one. */ + new_timer(&timers, 169000000); + ok1(timers_check(&timers, NULL)); + + /* Used to get the wrong one... */ + timers_dump(&timers, stdout); + ok1(timer_earliest(&timers, &when)); + ok1(when.ts.tv_nsec == 168000000); + free(timers_expire(&timers, when)); + + ok1(timer_earliest(&timers, &when)); + ok1(when.ts.tv_nsec == 169000000); + free(timers_expire(&timers, when)); + + ok1(timers_check(&timers, NULL)); + ok1(!timer_earliest(&timers, &when)); + timers_cleanup(&timers); + + return exit_status(); +} diff --git a/ccan/timer/test/run-original-corrupt.c b/ccan/timer/test/run-original-corrupt.c new file mode 100644 index 00000000..8bd2b428 --- /dev/null +++ b/ccan/timer/test/run-original-corrupt.c @@ -0,0 +1,4332 @@ +#define CCAN_TIMER_DEBUG 1 +#include +/* Include the C files directly. */ +#include +#include + +/* This is the original pre-cut-down dump. */ +int main(int argc, char *argv[]) +{ + struct timeabs when; + struct timers timers; + struct timer *timer; + + plan_tests(2); + + when.ts.tv_sec = 0; when.ts.tv_nsec = 0; + timers_init(&timers, when); + + when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&timers, timer, when); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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_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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, 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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000; + timer = malloc(sizeof(*timer)); + timer_init(timer); + timer_add(&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); + ok1(timers_check(&timers, NULL)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + timer_earliest(&timers, &when); + free(timers_expire(&timers, when)); + + while (timer_earliest(&timers, &when)) { + free(timers_expire(&timers, when)); + } + ok1(timers_check(&timers, NULL)); + timers_cleanup(&timers); + + return exit_status(); +} diff --git a/ccan/timer/timer.c b/ccan/timer/timer.c index f0e017ba..4e0b7101 100644 --- a/ccan/timer/timer.c +++ b/ccan/timer/timer.c @@ -180,6 +180,10 @@ next: if (i == PER_LEVEL) { level++; base >>= TIMER_LEVEL_BITS; + if (off != 0) + /* We need *next* bucket: we've started reusing the + * one above */ + base++; goto next; } @@ -189,14 +193,23 @@ next: else found = find_first(h, NULL); - if (need_next) { + while (need_next) { + need_next = false; if (!timers->level[level+1]) { found = find_first(&timers->far, found); } else { + /* Current upper bucket has emptied into this + * bucket; we want *next* one. */ base >>= TIMER_LEVEL_BITS; + base++; off = base % PER_LEVEL; - h = &timers->level[level+1]->list[off]; - found = find_first(h, found); + + if (off == 0) { + need_next = true; + } else { + h = &timers->level[level+1]->list[off]; + found = find_first(h, found); + } } } return found; -- 2.39.2