1 #define CCAN_TIMER_DEBUG 1
2 #include <ccan/timer/timer.h>
3 /* Include the C files directly. */
4 #include <ccan/timer/timer.c>
5 #include <ccan/tap/tap.h>
7 /* This is the original pre-cut-down dump. */
8 int main(int argc, char *argv[])
16 when.ts.tv_sec = 0; when.ts.tv_nsec = 0;
17 timers_init(&timers, when);
19 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
20 timer = malloc(sizeof(*timer));
22 timer_add(&timers, timer, when);
23 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
24 timer = malloc(sizeof(*timer));
26 timer_add(&timers, timer, when);
27 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
28 timer = malloc(sizeof(*timer));
30 timer_add(&timers, timer, when);
31 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
32 timer = malloc(sizeof(*timer));
34 timer_add(&timers, timer, when);
35 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
36 timer = malloc(sizeof(*timer));
38 timer_add(&timers, timer, when);
39 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
40 timer = malloc(sizeof(*timer));
42 timer_add(&timers, timer, when);
43 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
44 timer = malloc(sizeof(*timer));
46 timer_add(&timers, timer, when);
47 when.ts.tv_sec = 0; when.ts.tv_nsec = 18000000;
48 timer = malloc(sizeof(*timer));
50 timer_add(&timers, timer, when);
51 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
52 timer = malloc(sizeof(*timer));
54 timer_add(&timers, timer, when);
55 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
56 timer = malloc(sizeof(*timer));
58 timer_add(&timers, timer, when);
59 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
60 timer = malloc(sizeof(*timer));
62 timer_add(&timers, timer, when);
63 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
64 timer = malloc(sizeof(*timer));
66 timer_add(&timers, timer, when);
67 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
68 timer = malloc(sizeof(*timer));
70 timer_add(&timers, timer, when);
71 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
72 timer = malloc(sizeof(*timer));
74 timer_add(&timers, timer, when);
75 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
76 timer = malloc(sizeof(*timer));
78 timer_add(&timers, timer, when);
79 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
80 timer = malloc(sizeof(*timer));
82 timer_add(&timers, timer, when);
83 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
84 timer = malloc(sizeof(*timer));
86 timer_add(&timers, timer, when);
87 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
88 timer = malloc(sizeof(*timer));
90 timer_add(&timers, timer, when);
91 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
92 timer = malloc(sizeof(*timer));
94 timer_add(&timers, timer, when);
95 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
96 timer = malloc(sizeof(*timer));
98 timer_add(&timers, timer, when);
99 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
100 timer = malloc(sizeof(*timer));
102 timer_add(&timers, timer, when);
103 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
104 timer = malloc(sizeof(*timer));
106 timer_add(&timers, timer, when);
107 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
108 timer = malloc(sizeof(*timer));
110 timer_add(&timers, timer, when);
111 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
112 timer = malloc(sizeof(*timer));
114 timer_add(&timers, timer, when);
115 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
116 timer = malloc(sizeof(*timer));
118 timer_add(&timers, timer, when);
119 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
120 timer = malloc(sizeof(*timer));
122 timer_add(&timers, timer, when);
123 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
124 timer = malloc(sizeof(*timer));
126 timer_add(&timers, timer, when);
127 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
128 timer = malloc(sizeof(*timer));
130 timer_add(&timers, timer, when);
131 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
132 timer = malloc(sizeof(*timer));
134 timer_add(&timers, timer, when);
135 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
136 timer = malloc(sizeof(*timer));
138 timer_add(&timers, timer, when);
139 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
140 timer = malloc(sizeof(*timer));
142 timer_add(&timers, timer, when);
143 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
144 timer = malloc(sizeof(*timer));
146 timer_add(&timers, timer, when);
147 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
148 timer = malloc(sizeof(*timer));
150 timer_add(&timers, timer, when);
151 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
152 timer = malloc(sizeof(*timer));
154 timer_add(&timers, timer, when);
155 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
156 timer = malloc(sizeof(*timer));
158 timer_add(&timers, timer, when);
159 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
160 timer = malloc(sizeof(*timer));
162 timer_add(&timers, timer, when);
163 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
164 timer = malloc(sizeof(*timer));
166 timer_add(&timers, timer, when);
167 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
168 timer = malloc(sizeof(*timer));
170 timer_add(&timers, timer, when);
171 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
172 timer = malloc(sizeof(*timer));
174 timer_add(&timers, timer, when);
175 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
176 timer = malloc(sizeof(*timer));
178 timer_add(&timers, timer, when);
179 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
180 timer = malloc(sizeof(*timer));
182 timer_add(&timers, timer, when);
183 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
184 timer = malloc(sizeof(*timer));
186 timer_add(&timers, timer, when);
187 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
188 timer = malloc(sizeof(*timer));
190 timer_add(&timers, timer, when);
191 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
192 timer = malloc(sizeof(*timer));
194 timer_add(&timers, timer, when);
195 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
196 timer = malloc(sizeof(*timer));
198 timer_add(&timers, timer, when);
199 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
200 timer = malloc(sizeof(*timer));
202 timer_add(&timers, timer, when);
203 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
204 timer = malloc(sizeof(*timer));
206 timer_add(&timers, timer, when);
207 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
208 timer = malloc(sizeof(*timer));
210 timer_add(&timers, timer, when);
211 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
212 timer = malloc(sizeof(*timer));
214 timer_add(&timers, timer, when);
215 when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
216 timer = malloc(sizeof(*timer));
218 timer_add(&timers, timer, when);
219 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
220 timer = malloc(sizeof(*timer));
222 timer_add(&timers, timer, when);
223 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
224 timer = malloc(sizeof(*timer));
226 timer_add(&timers, timer, when);
227 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
228 timer = malloc(sizeof(*timer));
230 timer_add(&timers, timer, when);
231 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
232 timer = malloc(sizeof(*timer));
234 timer_add(&timers, timer, when);
235 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
236 timer = malloc(sizeof(*timer));
238 timer_add(&timers, timer, when);
239 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
240 timer = malloc(sizeof(*timer));
242 timer_add(&timers, timer, when);
243 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
244 timer = malloc(sizeof(*timer));
246 timer_add(&timers, timer, when);
247 when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
248 timer = malloc(sizeof(*timer));
250 timer_add(&timers, timer, when);
251 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
252 timer = malloc(sizeof(*timer));
254 timer_add(&timers, timer, when);
255 when.ts.tv_sec = 0; when.ts.tv_nsec = 13000000;
256 timer = malloc(sizeof(*timer));
258 timer_add(&timers, timer, when);
259 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
260 timer = malloc(sizeof(*timer));
262 timer_add(&timers, timer, when);
263 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
264 timer = malloc(sizeof(*timer));
266 timer_add(&timers, timer, when);
267 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
268 timer = malloc(sizeof(*timer));
270 timer_add(&timers, timer, when);
271 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
272 timer = malloc(sizeof(*timer));
274 timer_add(&timers, timer, when);
275 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
276 timer = malloc(sizeof(*timer));
278 timer_add(&timers, timer, when);
279 when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
280 timer = malloc(sizeof(*timer));
282 timer_add(&timers, timer, when);
283 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
284 timer = malloc(sizeof(*timer));
286 timer_add(&timers, timer, when);
287 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
288 timer = malloc(sizeof(*timer));
290 timer_add(&timers, timer, when);
291 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
292 timer = malloc(sizeof(*timer));
294 timer_add(&timers, timer, when);
295 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
296 timer = malloc(sizeof(*timer));
298 timer_add(&timers, timer, when);
299 when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
300 timer = malloc(sizeof(*timer));
302 timer_add(&timers, timer, when);
303 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
304 timer = malloc(sizeof(*timer));
306 timer_add(&timers, timer, when);
307 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
308 timer = malloc(sizeof(*timer));
310 timer_add(&timers, timer, when);
311 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
312 timer = malloc(sizeof(*timer));
314 timer_add(&timers, timer, when);
315 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
316 timer = malloc(sizeof(*timer));
318 timer_add(&timers, timer, when);
319 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
320 timer = malloc(sizeof(*timer));
322 timer_add(&timers, timer, when);
323 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
324 timer = malloc(sizeof(*timer));
326 timer_add(&timers, timer, when);
327 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
328 timer = malloc(sizeof(*timer));
330 timer_add(&timers, timer, when);
331 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
332 timer = malloc(sizeof(*timer));
334 timer_add(&timers, timer, when);
335 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
336 timer = malloc(sizeof(*timer));
338 timer_add(&timers, timer, when);
339 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
340 timer = malloc(sizeof(*timer));
342 timer_add(&timers, timer, when);
343 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
344 timer = malloc(sizeof(*timer));
346 timer_add(&timers, timer, when);
347 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
348 timer = malloc(sizeof(*timer));
350 timer_add(&timers, timer, when);
351 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
352 timer = malloc(sizeof(*timer));
354 timer_add(&timers, timer, when);
355 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
356 timer = malloc(sizeof(*timer));
358 timer_add(&timers, timer, when);
359 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
360 timer = malloc(sizeof(*timer));
362 timer_add(&timers, timer, when);
363 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
364 timer = malloc(sizeof(*timer));
366 timer_add(&timers, timer, when);
367 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
368 timer = malloc(sizeof(*timer));
370 timer_add(&timers, timer, when);
371 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
372 timer = malloc(sizeof(*timer));
374 timer_add(&timers, timer, when);
375 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
376 timer = malloc(sizeof(*timer));
378 timer_add(&timers, timer, when);
379 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
380 timer = malloc(sizeof(*timer));
382 timer_add(&timers, timer, when);
383 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
384 timer = malloc(sizeof(*timer));
386 timer_add(&timers, timer, when);
387 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
388 timer = malloc(sizeof(*timer));
390 timer_add(&timers, timer, when);
391 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
392 timer = malloc(sizeof(*timer));
394 timer_add(&timers, timer, when);
395 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
396 timer = malloc(sizeof(*timer));
398 timer_add(&timers, timer, when);
399 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
400 timer = malloc(sizeof(*timer));
402 timer_add(&timers, timer, when);
403 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
404 timer = malloc(sizeof(*timer));
406 timer_add(&timers, timer, when);
407 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
408 timer = malloc(sizeof(*timer));
410 timer_add(&timers, timer, when);
411 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
412 timer = malloc(sizeof(*timer));
414 timer_add(&timers, timer, when);
415 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
416 timer = malloc(sizeof(*timer));
418 timer_add(&timers, timer, when);
419 when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
420 timer = malloc(sizeof(*timer));
422 timer_add(&timers, timer, when);
423 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
424 timer = malloc(sizeof(*timer));
426 timer_add(&timers, timer, when);
427 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
428 timer = malloc(sizeof(*timer));
430 timer_add(&timers, timer, when);
431 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
432 timer = malloc(sizeof(*timer));
434 timer_add(&timers, timer, when);
435 when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000;
436 timer = malloc(sizeof(*timer));
438 timer_add(&timers, timer, when);
439 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
440 timer = malloc(sizeof(*timer));
442 timer_add(&timers, timer, when);
443 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
444 timer = malloc(sizeof(*timer));
446 timer_add(&timers, timer, when);
447 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
448 timer = malloc(sizeof(*timer));
450 timer_add(&timers, timer, when);
451 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
452 timer = malloc(sizeof(*timer));
454 timer_add(&timers, timer, when);
455 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
456 timer = malloc(sizeof(*timer));
458 timer_add(&timers, timer, when);
459 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
460 timer = malloc(sizeof(*timer));
462 timer_add(&timers, timer, when);
463 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
464 timer = malloc(sizeof(*timer));
466 timer_add(&timers, timer, when);
467 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
468 timer = malloc(sizeof(*timer));
470 timer_add(&timers, timer, when);
471 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
472 timer = malloc(sizeof(*timer));
474 timer_add(&timers, timer, when);
475 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
476 timer = malloc(sizeof(*timer));
478 timer_add(&timers, timer, when);
479 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
480 timer = malloc(sizeof(*timer));
482 timer_add(&timers, timer, when);
483 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
484 timer = malloc(sizeof(*timer));
486 timer_add(&timers, timer, when);
487 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
488 timer = malloc(sizeof(*timer));
490 timer_add(&timers, timer, when);
491 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
492 timer = malloc(sizeof(*timer));
494 timer_add(&timers, timer, when);
495 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
496 timer = malloc(sizeof(*timer));
498 timer_add(&timers, timer, when);
499 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
500 timer = malloc(sizeof(*timer));
502 timer_add(&timers, timer, when);
503 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
504 timer = malloc(sizeof(*timer));
506 timer_add(&timers, timer, when);
507 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
508 timer = malloc(sizeof(*timer));
510 timer_add(&timers, timer, when);
511 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
512 timer = malloc(sizeof(*timer));
514 timer_add(&timers, timer, when);
515 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
516 timer = malloc(sizeof(*timer));
518 timer_add(&timers, timer, when);
519 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
520 timer = malloc(sizeof(*timer));
522 timer_add(&timers, timer, when);
523 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
524 timer = malloc(sizeof(*timer));
526 timer_add(&timers, timer, when);
527 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
528 timer = malloc(sizeof(*timer));
530 timer_add(&timers, timer, when);
531 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
532 timer = malloc(sizeof(*timer));
534 timer_add(&timers, timer, when);
535 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
536 timer = malloc(sizeof(*timer));
538 timer_add(&timers, timer, when);
539 when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
540 timer = malloc(sizeof(*timer));
542 timer_add(&timers, timer, when);
543 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
544 timer = malloc(sizeof(*timer));
546 timer_add(&timers, timer, when);
547 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
548 timer = malloc(sizeof(*timer));
550 timer_add(&timers, timer, when);
551 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
552 timer = malloc(sizeof(*timer));
554 timer_add(&timers, timer, when);
555 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
556 timer = malloc(sizeof(*timer));
558 timer_add(&timers, timer, when);
559 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
560 timer = malloc(sizeof(*timer));
562 timer_add(&timers, timer, when);
563 when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
564 timer = malloc(sizeof(*timer));
566 timer_add(&timers, timer, when);
567 when.ts.tv_sec = 0; when.ts.tv_nsec = 90000000;
568 timer = malloc(sizeof(*timer));
570 timer_add(&timers, timer, when);
571 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
572 timer = malloc(sizeof(*timer));
574 timer_add(&timers, timer, when);
575 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
576 timer = malloc(sizeof(*timer));
578 timer_add(&timers, timer, when);
579 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
580 timer = malloc(sizeof(*timer));
582 timer_add(&timers, timer, when);
583 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
584 timer = malloc(sizeof(*timer));
586 timer_add(&timers, timer, when);
587 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
588 timer = malloc(sizeof(*timer));
590 timer_add(&timers, timer, when);
591 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
592 timer = malloc(sizeof(*timer));
594 timer_add(&timers, timer, when);
595 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
596 timer = malloc(sizeof(*timer));
598 timer_add(&timers, timer, when);
599 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
600 timer = malloc(sizeof(*timer));
602 timer_add(&timers, timer, when);
603 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
604 timer = malloc(sizeof(*timer));
606 timer_add(&timers, timer, when);
607 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
608 timer = malloc(sizeof(*timer));
610 timer_add(&timers, timer, when);
611 when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
612 timer = malloc(sizeof(*timer));
614 timer_add(&timers, timer, when);
615 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
616 timer = malloc(sizeof(*timer));
618 timer_add(&timers, timer, when);
619 when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000;
620 timer = malloc(sizeof(*timer));
622 timer_add(&timers, timer, when);
623 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
624 timer = malloc(sizeof(*timer));
626 timer_add(&timers, timer, when);
627 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
628 timer = malloc(sizeof(*timer));
630 timer_add(&timers, timer, when);
631 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
632 timer = malloc(sizeof(*timer));
634 timer_add(&timers, timer, when);
635 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
636 timer = malloc(sizeof(*timer));
638 timer_add(&timers, timer, when);
639 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
640 timer = malloc(sizeof(*timer));
642 timer_add(&timers, timer, when);
643 when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
644 timer = malloc(sizeof(*timer));
646 timer_add(&timers, timer, when);
647 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
648 timer = malloc(sizeof(*timer));
650 timer_add(&timers, timer, when);
651 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
652 timer = malloc(sizeof(*timer));
654 timer_add(&timers, timer, when);
655 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
656 timer = malloc(sizeof(*timer));
658 timer_add(&timers, timer, when);
659 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
660 timer = malloc(sizeof(*timer));
662 timer_add(&timers, timer, when);
663 when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
664 timer = malloc(sizeof(*timer));
666 timer_add(&timers, timer, when);
667 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
668 timer = malloc(sizeof(*timer));
670 timer_add(&timers, timer, when);
671 when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
672 timer = malloc(sizeof(*timer));
674 timer_add(&timers, timer, when);
675 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
676 timer = malloc(sizeof(*timer));
678 timer_add(&timers, timer, when);
679 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
680 timer = malloc(sizeof(*timer));
682 timer_add(&timers, timer, when);
683 when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
684 timer = malloc(sizeof(*timer));
686 timer_add(&timers, timer, when);
687 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
688 timer = malloc(sizeof(*timer));
690 timer_add(&timers, timer, when);
691 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
692 timer = malloc(sizeof(*timer));
694 timer_add(&timers, timer, when);
695 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
696 timer = malloc(sizeof(*timer));
698 timer_add(&timers, timer, when);
699 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
700 timer = malloc(sizeof(*timer));
702 timer_add(&timers, timer, when);
703 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
704 timer = malloc(sizeof(*timer));
706 timer_add(&timers, timer, when);
707 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
708 timer = malloc(sizeof(*timer));
710 timer_add(&timers, timer, when);
711 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
712 timer = malloc(sizeof(*timer));
714 timer_add(&timers, timer, when);
715 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
716 timer = malloc(sizeof(*timer));
718 timer_add(&timers, timer, when);
719 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
720 timer = malloc(sizeof(*timer));
722 timer_add(&timers, timer, when);
723 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
724 timer = malloc(sizeof(*timer));
726 timer_add(&timers, timer, when);
727 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
728 timer = malloc(sizeof(*timer));
730 timer_add(&timers, timer, when);
731 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
732 timer = malloc(sizeof(*timer));
734 timer_add(&timers, timer, when);
735 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
736 timer = malloc(sizeof(*timer));
738 timer_add(&timers, timer, when);
739 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
740 timer = malloc(sizeof(*timer));
742 timer_add(&timers, timer, when);
743 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
744 timer = malloc(sizeof(*timer));
746 timer_add(&timers, timer, when);
747 when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
748 timer = malloc(sizeof(*timer));
750 timer_add(&timers, timer, when);
751 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
752 timer = malloc(sizeof(*timer));
754 timer_add(&timers, timer, when);
755 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
756 timer = malloc(sizeof(*timer));
758 timer_add(&timers, timer, when);
759 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
760 timer = malloc(sizeof(*timer));
762 timer_add(&timers, timer, when);
763 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
764 timer = malloc(sizeof(*timer));
766 timer_add(&timers, timer, when);
767 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
768 timer = malloc(sizeof(*timer));
770 timer_add(&timers, timer, when);
771 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
772 timer = malloc(sizeof(*timer));
774 timer_add(&timers, timer, when);
775 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
776 timer = malloc(sizeof(*timer));
778 timer_add(&timers, timer, when);
779 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
780 timer = malloc(sizeof(*timer));
782 timer_add(&timers, timer, when);
783 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
784 timer = malloc(sizeof(*timer));
786 timer_add(&timers, timer, when);
787 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
788 timer = malloc(sizeof(*timer));
790 timer_add(&timers, timer, when);
791 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
792 timer = malloc(sizeof(*timer));
794 timer_add(&timers, timer, when);
795 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
796 timer = malloc(sizeof(*timer));
798 timer_add(&timers, timer, when);
799 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
800 timer = malloc(sizeof(*timer));
802 timer_add(&timers, timer, when);
803 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
804 timer = malloc(sizeof(*timer));
806 timer_add(&timers, timer, when);
807 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
808 timer = malloc(sizeof(*timer));
810 timer_add(&timers, timer, when);
811 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
812 timer = malloc(sizeof(*timer));
814 timer_add(&timers, timer, when);
815 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
816 timer = malloc(sizeof(*timer));
818 timer_add(&timers, timer, when);
819 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
820 timer = malloc(sizeof(*timer));
822 timer_add(&timers, timer, when);
823 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
824 timer = malloc(sizeof(*timer));
826 timer_add(&timers, timer, when);
827 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
828 timer = malloc(sizeof(*timer));
830 timer_add(&timers, timer, when);
831 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
832 timer = malloc(sizeof(*timer));
834 timer_add(&timers, timer, when);
835 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
836 timer = malloc(sizeof(*timer));
838 timer_add(&timers, timer, when);
839 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
840 timer = malloc(sizeof(*timer));
842 timer_add(&timers, timer, when);
843 when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
844 timer = malloc(sizeof(*timer));
846 timer_add(&timers, timer, when);
847 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
848 timer = malloc(sizeof(*timer));
850 timer_add(&timers, timer, when);
851 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
852 timer = malloc(sizeof(*timer));
854 timer_add(&timers, timer, when);
855 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
856 timer = malloc(sizeof(*timer));
858 timer_add(&timers, timer, when);
859 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
860 timer = malloc(sizeof(*timer));
862 timer_add(&timers, timer, when);
863 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
864 timer = malloc(sizeof(*timer));
866 timer_add(&timers, timer, when);
867 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
868 timer = malloc(sizeof(*timer));
870 timer_add(&timers, timer, when);
871 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
872 timer = malloc(sizeof(*timer));
874 timer_add(&timers, timer, when);
875 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
876 timer = malloc(sizeof(*timer));
878 timer_add(&timers, timer, when);
879 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
880 timer = malloc(sizeof(*timer));
882 timer_add(&timers, timer, when);
883 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
884 timer = malloc(sizeof(*timer));
886 timer_add(&timers, timer, when);
887 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
888 timer = malloc(sizeof(*timer));
890 timer_add(&timers, timer, when);
891 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
892 timer = malloc(sizeof(*timer));
894 timer_add(&timers, timer, when);
895 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
896 timer = malloc(sizeof(*timer));
898 timer_add(&timers, timer, when);
899 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
900 timer = malloc(sizeof(*timer));
902 timer_add(&timers, timer, when);
903 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
904 timer = malloc(sizeof(*timer));
906 timer_add(&timers, timer, when);
907 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
908 timer = malloc(sizeof(*timer));
910 timer_add(&timers, timer, when);
911 when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
912 timer = malloc(sizeof(*timer));
914 timer_add(&timers, timer, when);
915 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
916 timer = malloc(sizeof(*timer));
918 timer_add(&timers, timer, when);
919 when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
920 timer = malloc(sizeof(*timer));
922 timer_add(&timers, timer, when);
923 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
924 timer = malloc(sizeof(*timer));
926 timer_add(&timers, timer, when);
927 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
928 timer = malloc(sizeof(*timer));
930 timer_add(&timers, timer, when);
931 when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000;
932 timer = malloc(sizeof(*timer));
934 timer_add(&timers, timer, when);
935 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
936 timer = malloc(sizeof(*timer));
938 timer_add(&timers, timer, when);
939 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
940 timer = malloc(sizeof(*timer));
942 timer_add(&timers, timer, when);
943 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
944 timer = malloc(sizeof(*timer));
946 timer_add(&timers, timer, when);
947 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
948 timer = malloc(sizeof(*timer));
950 timer_add(&timers, timer, when);
951 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
952 timer = malloc(sizeof(*timer));
954 timer_add(&timers, timer, when);
955 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
956 timer = malloc(sizeof(*timer));
958 timer_add(&timers, timer, when);
959 when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
960 timer = malloc(sizeof(*timer));
962 timer_add(&timers, timer, when);
963 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
964 timer = malloc(sizeof(*timer));
966 timer_add(&timers, timer, when);
967 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
968 timer = malloc(sizeof(*timer));
970 timer_add(&timers, timer, when);
971 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
972 timer = malloc(sizeof(*timer));
974 timer_add(&timers, timer, when);
975 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
976 timer = malloc(sizeof(*timer));
978 timer_add(&timers, timer, when);
979 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
980 timer = malloc(sizeof(*timer));
982 timer_add(&timers, timer, when);
983 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
984 timer = malloc(sizeof(*timer));
986 timer_add(&timers, timer, when);
987 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
988 timer = malloc(sizeof(*timer));
990 timer_add(&timers, timer, when);
991 when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
992 timer = malloc(sizeof(*timer));
994 timer_add(&timers, timer, when);
995 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
996 timer = malloc(sizeof(*timer));
998 timer_add(&timers, timer, when);
999 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1000 timer = malloc(sizeof(*timer));
1002 timer_add(&timers, timer, when);
1003 when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
1004 timer = malloc(sizeof(*timer));
1006 timer_add(&timers, timer, when);
1007 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1008 timer = malloc(sizeof(*timer));
1010 timer_add(&timers, timer, when);
1011 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
1012 timer = malloc(sizeof(*timer));
1014 timer_add(&timers, timer, when);
1015 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1016 timer = malloc(sizeof(*timer));
1018 timer_add(&timers, timer, when);
1019 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
1020 timer = malloc(sizeof(*timer));
1022 timer_add(&timers, timer, when);
1023 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
1024 timer = malloc(sizeof(*timer));
1026 timer_add(&timers, timer, when);
1027 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
1028 timer = malloc(sizeof(*timer));
1030 timer_add(&timers, timer, when);
1031 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1032 timer = malloc(sizeof(*timer));
1034 timer_add(&timers, timer, when);
1035 when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
1036 timer = malloc(sizeof(*timer));
1038 timer_add(&timers, timer, when);
1039 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
1040 timer = malloc(sizeof(*timer));
1042 timer_add(&timers, timer, when);
1043 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
1044 timer = malloc(sizeof(*timer));
1046 timer_add(&timers, timer, when);
1047 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
1048 timer = malloc(sizeof(*timer));
1050 timer_add(&timers, timer, when);
1051 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1052 timer = malloc(sizeof(*timer));
1054 timer_add(&timers, timer, when);
1055 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
1056 timer = malloc(sizeof(*timer));
1058 timer_add(&timers, timer, when);
1059 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
1060 timer = malloc(sizeof(*timer));
1062 timer_add(&timers, timer, when);
1063 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1064 timer = malloc(sizeof(*timer));
1066 timer_add(&timers, timer, when);
1067 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1068 timer = malloc(sizeof(*timer));
1070 timer_add(&timers, timer, when);
1071 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1072 timer = malloc(sizeof(*timer));
1074 timer_add(&timers, timer, when);
1075 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
1076 timer = malloc(sizeof(*timer));
1078 timer_add(&timers, timer, when);
1079 when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
1080 timer = malloc(sizeof(*timer));
1082 timer_add(&timers, timer, when);
1083 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1084 timer = malloc(sizeof(*timer));
1086 timer_add(&timers, timer, when);
1087 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1088 timer = malloc(sizeof(*timer));
1090 timer_add(&timers, timer, when);
1091 when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000;
1092 timer = malloc(sizeof(*timer));
1094 timer_add(&timers, timer, when);
1095 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
1096 timer = malloc(sizeof(*timer));
1098 timer_add(&timers, timer, when);
1099 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1100 timer = malloc(sizeof(*timer));
1102 timer_add(&timers, timer, when);
1103 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
1104 timer = malloc(sizeof(*timer));
1106 timer_add(&timers, timer, when);
1107 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1108 timer = malloc(sizeof(*timer));
1110 timer_add(&timers, timer, when);
1111 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1112 timer = malloc(sizeof(*timer));
1114 timer_add(&timers, timer, when);
1115 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
1116 timer = malloc(sizeof(*timer));
1118 timer_add(&timers, timer, when);
1119 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
1120 timer = malloc(sizeof(*timer));
1122 timer_add(&timers, timer, when);
1123 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
1124 timer = malloc(sizeof(*timer));
1126 timer_add(&timers, timer, when);
1127 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
1128 timer = malloc(sizeof(*timer));
1130 timer_add(&timers, timer, when);
1131 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
1132 timer = malloc(sizeof(*timer));
1134 timer_add(&timers, timer, when);
1135 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
1136 timer = malloc(sizeof(*timer));
1138 timer_add(&timers, timer, when);
1139 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1140 timer = malloc(sizeof(*timer));
1142 timer_add(&timers, timer, when);
1143 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
1144 timer = malloc(sizeof(*timer));
1146 timer_add(&timers, timer, when);
1147 when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
1148 timer = malloc(sizeof(*timer));
1150 timer_add(&timers, timer, when);
1151 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
1152 timer = malloc(sizeof(*timer));
1154 timer_add(&timers, timer, when);
1155 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
1156 timer = malloc(sizeof(*timer));
1158 timer_add(&timers, timer, when);
1159 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1160 timer = malloc(sizeof(*timer));
1162 timer_add(&timers, timer, when);
1163 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
1164 timer = malloc(sizeof(*timer));
1166 timer_add(&timers, timer, when);
1167 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
1168 timer = malloc(sizeof(*timer));
1170 timer_add(&timers, timer, when);
1171 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
1172 timer = malloc(sizeof(*timer));
1174 timer_add(&timers, timer, when);
1175 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
1176 timer = malloc(sizeof(*timer));
1178 timer_add(&timers, timer, when);
1179 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
1180 timer = malloc(sizeof(*timer));
1182 timer_add(&timers, timer, when);
1183 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
1184 timer = malloc(sizeof(*timer));
1186 timer_add(&timers, timer, when);
1187 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
1188 timer = malloc(sizeof(*timer));
1190 timer_add(&timers, timer, when);
1191 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
1192 timer = malloc(sizeof(*timer));
1194 timer_add(&timers, timer, when);
1195 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
1196 timer = malloc(sizeof(*timer));
1198 timer_add(&timers, timer, when);
1199 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1200 timer = malloc(sizeof(*timer));
1202 timer_add(&timers, timer, when);
1203 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1204 timer = malloc(sizeof(*timer));
1206 timer_add(&timers, timer, when);
1207 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
1208 timer = malloc(sizeof(*timer));
1210 timer_add(&timers, timer, when);
1211 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
1212 timer = malloc(sizeof(*timer));
1214 timer_add(&timers, timer, when);
1215 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1216 timer = malloc(sizeof(*timer));
1218 timer_add(&timers, timer, when);
1219 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
1220 timer = malloc(sizeof(*timer));
1222 timer_add(&timers, timer, when);
1223 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
1224 timer = malloc(sizeof(*timer));
1226 timer_add(&timers, timer, when);
1227 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
1228 timer = malloc(sizeof(*timer));
1230 timer_add(&timers, timer, when);
1231 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
1232 timer = malloc(sizeof(*timer));
1234 timer_add(&timers, timer, when);
1235 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
1236 timer = malloc(sizeof(*timer));
1238 timer_add(&timers, timer, when);
1239 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
1240 timer = malloc(sizeof(*timer));
1242 timer_add(&timers, timer, when);
1243 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
1244 timer = malloc(sizeof(*timer));
1246 timer_add(&timers, timer, when);
1247 when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
1248 timer = malloc(sizeof(*timer));
1250 timer_add(&timers, timer, when);
1251 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
1252 timer = malloc(sizeof(*timer));
1254 timer_add(&timers, timer, when);
1255 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1256 timer = malloc(sizeof(*timer));
1258 timer_add(&timers, timer, when);
1259 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
1260 timer = malloc(sizeof(*timer));
1262 timer_add(&timers, timer, when);
1263 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
1264 timer = malloc(sizeof(*timer));
1266 timer_add(&timers, timer, when);
1267 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1268 timer = malloc(sizeof(*timer));
1270 timer_add(&timers, timer, when);
1271 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
1272 timer = malloc(sizeof(*timer));
1274 timer_add(&timers, timer, when);
1275 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
1276 timer = malloc(sizeof(*timer));
1278 timer_add(&timers, timer, when);
1279 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1280 timer = malloc(sizeof(*timer));
1282 timer_add(&timers, timer, when);
1283 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
1284 timer = malloc(sizeof(*timer));
1286 timer_add(&timers, timer, when);
1287 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
1288 timer = malloc(sizeof(*timer));
1290 timer_add(&timers, timer, when);
1291 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
1292 timer = malloc(sizeof(*timer));
1294 timer_add(&timers, timer, when);
1295 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1296 timer = malloc(sizeof(*timer));
1298 timer_add(&timers, timer, when);
1299 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1300 timer = malloc(sizeof(*timer));
1302 timer_add(&timers, timer, when);
1303 when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
1304 timer = malloc(sizeof(*timer));
1306 timer_add(&timers, timer, when);
1307 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
1308 timer = malloc(sizeof(*timer));
1310 timer_add(&timers, timer, when);
1311 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
1312 timer = malloc(sizeof(*timer));
1314 timer_add(&timers, timer, when);
1315 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1316 timer = malloc(sizeof(*timer));
1318 timer_add(&timers, timer, when);
1319 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
1320 timer = malloc(sizeof(*timer));
1322 timer_add(&timers, timer, when);
1323 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
1324 timer = malloc(sizeof(*timer));
1326 timer_add(&timers, timer, when);
1327 when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
1328 timer = malloc(sizeof(*timer));
1330 timer_add(&timers, timer, when);
1331 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
1332 timer = malloc(sizeof(*timer));
1334 timer_add(&timers, timer, when);
1335 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1336 timer = malloc(sizeof(*timer));
1338 timer_add(&timers, timer, when);
1339 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
1340 timer = malloc(sizeof(*timer));
1342 timer_add(&timers, timer, when);
1343 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
1344 timer = malloc(sizeof(*timer));
1346 timer_add(&timers, timer, when);
1347 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
1348 timer = malloc(sizeof(*timer));
1350 timer_add(&timers, timer, when);
1351 when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
1352 timer = malloc(sizeof(*timer));
1354 timer_add(&timers, timer, when);
1355 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1356 timer = malloc(sizeof(*timer));
1358 timer_add(&timers, timer, when);
1359 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
1360 timer = malloc(sizeof(*timer));
1362 timer_add(&timers, timer, when);
1363 when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
1364 timer = malloc(sizeof(*timer));
1366 timer_add(&timers, timer, when);
1367 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
1368 timer = malloc(sizeof(*timer));
1370 timer_add(&timers, timer, when);
1371 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1372 timer = malloc(sizeof(*timer));
1374 timer_add(&timers, timer, when);
1375 when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
1376 timer = malloc(sizeof(*timer));
1378 timer_add(&timers, timer, when);
1379 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
1380 timer = malloc(sizeof(*timer));
1382 timer_add(&timers, timer, when);
1383 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
1384 timer = malloc(sizeof(*timer));
1386 timer_add(&timers, timer, when);
1387 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
1388 timer = malloc(sizeof(*timer));
1390 timer_add(&timers, timer, when);
1391 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1392 timer = malloc(sizeof(*timer));
1394 timer_add(&timers, timer, when);
1395 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
1396 timer = malloc(sizeof(*timer));
1398 timer_add(&timers, timer, when);
1399 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
1400 timer = malloc(sizeof(*timer));
1402 timer_add(&timers, timer, when);
1403 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1404 timer = malloc(sizeof(*timer));
1406 timer_add(&timers, timer, when);
1407 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
1408 timer = malloc(sizeof(*timer));
1410 timer_add(&timers, timer, when);
1411 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
1412 timer = malloc(sizeof(*timer));
1414 timer_add(&timers, timer, when);
1415 when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
1416 timer = malloc(sizeof(*timer));
1418 timer_add(&timers, timer, when);
1419 when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
1420 timer = malloc(sizeof(*timer));
1422 timer_add(&timers, timer, when);
1423 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1424 timer = malloc(sizeof(*timer));
1426 timer_add(&timers, timer, when);
1427 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1428 timer = malloc(sizeof(*timer));
1430 timer_add(&timers, timer, when);
1431 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
1432 timer = malloc(sizeof(*timer));
1434 timer_add(&timers, timer, when);
1435 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
1436 timer = malloc(sizeof(*timer));
1438 timer_add(&timers, timer, when);
1439 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
1440 timer = malloc(sizeof(*timer));
1442 timer_add(&timers, timer, when);
1443 when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000;
1444 timer = malloc(sizeof(*timer));
1446 timer_add(&timers, timer, when);
1447 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1448 timer = malloc(sizeof(*timer));
1450 timer_add(&timers, timer, when);
1451 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
1452 timer = malloc(sizeof(*timer));
1454 timer_add(&timers, timer, when);
1455 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
1456 timer = malloc(sizeof(*timer));
1458 timer_add(&timers, timer, when);
1459 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1460 timer = malloc(sizeof(*timer));
1462 timer_add(&timers, timer, when);
1463 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1464 timer = malloc(sizeof(*timer));
1466 timer_add(&timers, timer, when);
1467 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
1468 timer = malloc(sizeof(*timer));
1470 timer_add(&timers, timer, when);
1471 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
1472 timer = malloc(sizeof(*timer));
1474 timer_add(&timers, timer, when);
1475 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
1476 timer = malloc(sizeof(*timer));
1478 timer_add(&timers, timer, when);
1479 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
1480 timer = malloc(sizeof(*timer));
1482 timer_add(&timers, timer, when);
1483 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
1484 timer = malloc(sizeof(*timer));
1486 timer_add(&timers, timer, when);
1487 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1488 timer = malloc(sizeof(*timer));
1490 timer_add(&timers, timer, when);
1491 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1492 timer = malloc(sizeof(*timer));
1494 timer_add(&timers, timer, when);
1495 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
1496 timer = malloc(sizeof(*timer));
1498 timer_add(&timers, timer, when);
1499 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
1500 timer = malloc(sizeof(*timer));
1502 timer_add(&timers, timer, when);
1503 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1504 timer = malloc(sizeof(*timer));
1506 timer_add(&timers, timer, when);
1507 when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000;
1508 timer = malloc(sizeof(*timer));
1510 timer_add(&timers, timer, when);
1511 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1512 timer = malloc(sizeof(*timer));
1514 timer_add(&timers, timer, when);
1515 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1516 timer = malloc(sizeof(*timer));
1518 timer_add(&timers, timer, when);
1519 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1520 timer = malloc(sizeof(*timer));
1522 timer_add(&timers, timer, when);
1523 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1524 timer = malloc(sizeof(*timer));
1526 timer_add(&timers, timer, when);
1527 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
1528 timer = malloc(sizeof(*timer));
1530 timer_add(&timers, timer, when);
1531 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
1532 timer = malloc(sizeof(*timer));
1534 timer_add(&timers, timer, when);
1535 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
1536 timer = malloc(sizeof(*timer));
1538 timer_add(&timers, timer, when);
1539 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
1540 timer = malloc(sizeof(*timer));
1542 timer_add(&timers, timer, when);
1543 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1544 timer = malloc(sizeof(*timer));
1546 timer_add(&timers, timer, when);
1547 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
1548 timer = malloc(sizeof(*timer));
1550 timer_add(&timers, timer, when);
1551 when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
1552 timer = malloc(sizeof(*timer));
1554 timer_add(&timers, timer, when);
1555 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
1556 timer = malloc(sizeof(*timer));
1558 timer_add(&timers, timer, when);
1559 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
1560 timer = malloc(sizeof(*timer));
1562 timer_add(&timers, timer, when);
1563 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1564 timer = malloc(sizeof(*timer));
1566 timer_add(&timers, timer, when);
1567 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
1568 timer = malloc(sizeof(*timer));
1570 timer_add(&timers, timer, when);
1571 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
1572 timer = malloc(sizeof(*timer));
1574 timer_add(&timers, timer, when);
1575 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
1576 timer = malloc(sizeof(*timer));
1578 timer_add(&timers, timer, when);
1579 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1580 timer = malloc(sizeof(*timer));
1582 timer_add(&timers, timer, when);
1583 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
1584 timer = malloc(sizeof(*timer));
1586 timer_add(&timers, timer, when);
1587 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
1588 timer = malloc(sizeof(*timer));
1590 timer_add(&timers, timer, when);
1591 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1592 timer = malloc(sizeof(*timer));
1594 timer_add(&timers, timer, when);
1595 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1596 timer = malloc(sizeof(*timer));
1598 timer_add(&timers, timer, when);
1599 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1600 timer = malloc(sizeof(*timer));
1602 timer_add(&timers, timer, when);
1603 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
1604 timer = malloc(sizeof(*timer));
1606 timer_add(&timers, timer, when);
1607 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
1608 timer = malloc(sizeof(*timer));
1610 timer_add(&timers, timer, when);
1611 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
1612 timer = malloc(sizeof(*timer));
1614 timer_add(&timers, timer, when);
1615 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1616 timer = malloc(sizeof(*timer));
1618 timer_add(&timers, timer, when);
1619 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
1620 timer = malloc(sizeof(*timer));
1622 timer_add(&timers, timer, when);
1623 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
1624 timer = malloc(sizeof(*timer));
1626 timer_add(&timers, timer, when);
1627 timer_earliest(&timers, &when);
1628 free(timers_expire(&timers, when));
1629 timer_earliest(&timers, &when);
1630 free(timers_expire(&timers, when));
1631 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1632 timer = malloc(sizeof(*timer));
1634 timer_add(&timers, timer, when);
1635 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
1636 timer = malloc(sizeof(*timer));
1638 timer_add(&timers, timer, when);
1639 when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1640 timer = malloc(sizeof(*timer));
1642 timer_add(&timers, timer, when);
1643 timer_earliest(&timers, &when);
1644 free(timers_expire(&timers, when));
1645 when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
1646 timer = malloc(sizeof(*timer));
1648 timer_add(&timers, timer, when);
1649 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1650 timer = malloc(sizeof(*timer));
1652 timer_add(&timers, timer, when);
1653 timer_earliest(&timers, &when);
1654 free(timers_expire(&timers, when));
1655 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
1656 timer = malloc(sizeof(*timer));
1658 timer_add(&timers, timer, when);
1659 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
1660 timer = malloc(sizeof(*timer));
1662 timer_add(&timers, timer, when);
1663 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1664 timer = malloc(sizeof(*timer));
1666 timer_add(&timers, timer, when);
1667 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
1668 timer = malloc(sizeof(*timer));
1670 timer_add(&timers, timer, when);
1671 timer_earliest(&timers, &when);
1672 free(timers_expire(&timers, when));
1673 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1674 timer = malloc(sizeof(*timer));
1676 timer_add(&timers, timer, when);
1677 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
1678 timer = malloc(sizeof(*timer));
1680 timer_add(&timers, timer, when);
1681 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1682 timer = malloc(sizeof(*timer));
1684 timer_add(&timers, timer, when);
1685 timer_earliest(&timers, &when);
1686 free(timers_expire(&timers, when));
1687 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1688 timer = malloc(sizeof(*timer));
1690 timer_add(&timers, timer, when);
1691 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1692 timer = malloc(sizeof(*timer));
1694 timer_add(&timers, timer, when);
1695 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1696 timer = malloc(sizeof(*timer));
1698 timer_add(&timers, timer, when);
1699 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1700 timer = malloc(sizeof(*timer));
1702 timer_add(&timers, timer, when);
1703 when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
1704 timer = malloc(sizeof(*timer));
1706 timer_add(&timers, timer, when);
1707 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1708 timer = malloc(sizeof(*timer));
1710 timer_add(&timers, timer, when);
1711 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
1712 timer = malloc(sizeof(*timer));
1714 timer_add(&timers, timer, when);
1715 timer_earliest(&timers, &when);
1716 free(timers_expire(&timers, when));
1717 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1718 timer = malloc(sizeof(*timer));
1720 timer_add(&timers, timer, when);
1721 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
1722 timer = malloc(sizeof(*timer));
1724 timer_add(&timers, timer, when);
1725 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
1726 timer = malloc(sizeof(*timer));
1728 timer_add(&timers, timer, when);
1729 timer_earliest(&timers, &when);
1730 free(timers_expire(&timers, when));
1731 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1732 timer = malloc(sizeof(*timer));
1734 timer_add(&timers, timer, when);
1735 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
1736 timer = malloc(sizeof(*timer));
1738 timer_add(&timers, timer, when);
1739 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
1740 timer = malloc(sizeof(*timer));
1742 timer_add(&timers, timer, when);
1743 timer_earliest(&timers, &when);
1744 free(timers_expire(&timers, when));
1745 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1746 timer = malloc(sizeof(*timer));
1748 timer_add(&timers, timer, when);
1749 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1750 timer = malloc(sizeof(*timer));
1752 timer_add(&timers, timer, when);
1753 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1754 timer = malloc(sizeof(*timer));
1756 timer_add(&timers, timer, when);
1757 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
1758 timer = malloc(sizeof(*timer));
1760 timer_add(&timers, timer, when);
1761 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1762 timer = malloc(sizeof(*timer));
1764 timer_add(&timers, timer, when);
1765 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
1766 timer = malloc(sizeof(*timer));
1768 timer_add(&timers, timer, when);
1769 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1770 timer = malloc(sizeof(*timer));
1772 timer_add(&timers, timer, when);
1773 timer_earliest(&timers, &when);
1774 free(timers_expire(&timers, when));
1775 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1776 timer = malloc(sizeof(*timer));
1778 timer_add(&timers, timer, when);
1779 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
1780 timer = malloc(sizeof(*timer));
1782 timer_add(&timers, timer, when);
1783 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
1784 timer = malloc(sizeof(*timer));
1786 timer_add(&timers, timer, when);
1787 timer_earliest(&timers, &when);
1788 free(timers_expire(&timers, when));
1789 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1790 timer = malloc(sizeof(*timer));
1792 timer_add(&timers, timer, when);
1793 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1794 timer = malloc(sizeof(*timer));
1796 timer_add(&timers, timer, when);
1797 when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
1798 timer = malloc(sizeof(*timer));
1800 timer_add(&timers, timer, when);
1801 timer_earliest(&timers, &when);
1802 free(timers_expire(&timers, when));
1803 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
1804 timer = malloc(sizeof(*timer));
1806 timer_add(&timers, timer, when);
1807 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
1808 timer = malloc(sizeof(*timer));
1810 timer_add(&timers, timer, when);
1811 when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1812 timer = malloc(sizeof(*timer));
1814 timer_add(&timers, timer, when);
1815 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
1816 timer = malloc(sizeof(*timer));
1818 timer_add(&timers, timer, when);
1819 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1820 timer = malloc(sizeof(*timer));
1822 timer_add(&timers, timer, when);
1823 timer_earliest(&timers, &when);
1824 free(timers_expire(&timers, when));
1825 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1826 timer = malloc(sizeof(*timer));
1828 timer_add(&timers, timer, when);
1829 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1830 timer = malloc(sizeof(*timer));
1832 timer_add(&timers, timer, when);
1833 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
1834 timer = malloc(sizeof(*timer));
1836 timer_add(&timers, timer, when);
1837 timer_earliest(&timers, &when);
1838 free(timers_expire(&timers, when));
1839 when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
1840 timer = malloc(sizeof(*timer));
1842 timer_add(&timers, timer, when);
1843 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
1844 timer = malloc(sizeof(*timer));
1846 timer_add(&timers, timer, when);
1847 timer_earliest(&timers, &when);
1848 free(timers_expire(&timers, when));
1849 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1850 timer = malloc(sizeof(*timer));
1852 timer_add(&timers, timer, when);
1853 timer_earliest(&timers, &when);
1854 free(timers_expire(&timers, when));
1855 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1856 timer = malloc(sizeof(*timer));
1858 timer_add(&timers, timer, when);
1859 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1860 timer = malloc(sizeof(*timer));
1862 timer_add(&timers, timer, when);
1863 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1864 timer = malloc(sizeof(*timer));
1866 timer_add(&timers, timer, when);
1867 timer_earliest(&timers, &when);
1868 free(timers_expire(&timers, when));
1869 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1870 timer = malloc(sizeof(*timer));
1872 timer_add(&timers, timer, when);
1873 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
1874 timer = malloc(sizeof(*timer));
1876 timer_add(&timers, timer, when);
1877 when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
1878 timer = malloc(sizeof(*timer));
1880 timer_add(&timers, timer, when);
1881 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
1882 timer = malloc(sizeof(*timer));
1884 timer_add(&timers, timer, when);
1885 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
1886 timer = malloc(sizeof(*timer));
1888 timer_add(&timers, timer, when);
1889 timer_earliest(&timers, &when);
1890 free(timers_expire(&timers, when));
1891 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1892 timer = malloc(sizeof(*timer));
1894 timer_add(&timers, timer, when);
1895 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
1896 timer = malloc(sizeof(*timer));
1898 timer_add(&timers, timer, when);
1899 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
1900 timer = malloc(sizeof(*timer));
1902 timer_add(&timers, timer, when);
1903 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
1904 timer = malloc(sizeof(*timer));
1906 timer_add(&timers, timer, when);
1907 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
1908 timer = malloc(sizeof(*timer));
1910 timer_add(&timers, timer, when);
1911 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
1912 timer = malloc(sizeof(*timer));
1914 timer_add(&timers, timer, when);
1915 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1916 timer = malloc(sizeof(*timer));
1918 timer_add(&timers, timer, when);
1919 timer_earliest(&timers, &when);
1920 free(timers_expire(&timers, when));
1921 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1922 timer = malloc(sizeof(*timer));
1924 timer_add(&timers, timer, when);
1925 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
1926 timer = malloc(sizeof(*timer));
1928 timer_add(&timers, timer, when);
1929 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1930 timer = malloc(sizeof(*timer));
1932 timer_add(&timers, timer, when);
1933 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1934 timer = malloc(sizeof(*timer));
1936 timer_add(&timers, timer, when);
1937 when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
1938 timer = malloc(sizeof(*timer));
1940 timer_add(&timers, timer, when);
1941 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1942 timer = malloc(sizeof(*timer));
1944 timer_add(&timers, timer, when);
1945 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1946 timer = malloc(sizeof(*timer));
1948 timer_add(&timers, timer, when);
1949 timer_earliest(&timers, &when);
1950 free(timers_expire(&timers, when));
1951 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
1952 timer = malloc(sizeof(*timer));
1954 timer_add(&timers, timer, when);
1955 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
1956 timer = malloc(sizeof(*timer));
1958 timer_add(&timers, timer, when);
1959 timer_earliest(&timers, &when);
1960 free(timers_expire(&timers, when));
1961 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1962 timer = malloc(sizeof(*timer));
1964 timer_add(&timers, timer, when);
1965 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1966 timer = malloc(sizeof(*timer));
1968 timer_add(&timers, timer, when);
1969 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
1970 timer = malloc(sizeof(*timer));
1972 timer_add(&timers, timer, when);
1973 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
1974 timer = malloc(sizeof(*timer));
1976 timer_add(&timers, timer, when);
1977 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
1978 timer = malloc(sizeof(*timer));
1980 timer_add(&timers, timer, when);
1981 timer_earliest(&timers, &when);
1982 free(timers_expire(&timers, when));
1983 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1984 timer = malloc(sizeof(*timer));
1986 timer_add(&timers, timer, when);
1987 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1988 timer = malloc(sizeof(*timer));
1990 timer_add(&timers, timer, when);
1991 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
1992 timer = malloc(sizeof(*timer));
1994 timer_add(&timers, timer, when);
1995 timer_earliest(&timers, &when);
1996 free(timers_expire(&timers, when));
1997 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
1998 timer = malloc(sizeof(*timer));
2000 timer_add(&timers, timer, when);
2001 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2002 timer = malloc(sizeof(*timer));
2004 timer_add(&timers, timer, when);
2005 timer_earliest(&timers, &when);
2006 free(timers_expire(&timers, when));
2007 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
2008 timer = malloc(sizeof(*timer));
2010 timer_add(&timers, timer, when);
2011 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
2012 timer = malloc(sizeof(*timer));
2014 timer_add(&timers, timer, when);
2015 timer_earliest(&timers, &when);
2016 free(timers_expire(&timers, when));
2017 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2018 timer = malloc(sizeof(*timer));
2020 timer_add(&timers, timer, when);
2021 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2022 timer = malloc(sizeof(*timer));
2024 timer_add(&timers, timer, when);
2025 when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
2026 timer = malloc(sizeof(*timer));
2028 timer_add(&timers, timer, when);
2029 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
2030 timer = malloc(sizeof(*timer));
2032 timer_add(&timers, timer, when);
2033 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
2034 timer = malloc(sizeof(*timer));
2036 timer_add(&timers, timer, when);
2037 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2038 timer = malloc(sizeof(*timer));
2040 timer_add(&timers, timer, when);
2041 timer_earliest(&timers, &when);
2042 free(timers_expire(&timers, when));
2043 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2044 timer = malloc(sizeof(*timer));
2046 timer_add(&timers, timer, when);
2047 when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2048 timer = malloc(sizeof(*timer));
2050 timer_add(&timers, timer, when);
2051 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2052 timer = malloc(sizeof(*timer));
2054 timer_add(&timers, timer, when);
2055 timer_earliest(&timers, &when);
2056 free(timers_expire(&timers, when));
2057 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2058 timer = malloc(sizeof(*timer));
2060 timer_add(&timers, timer, when);
2061 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2062 timer = malloc(sizeof(*timer));
2064 timer_add(&timers, timer, when);
2065 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2066 timer = malloc(sizeof(*timer));
2068 timer_add(&timers, timer, when);
2069 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2070 timer = malloc(sizeof(*timer));
2072 timer_add(&timers, timer, when);
2073 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
2074 timer = malloc(sizeof(*timer));
2076 timer_add(&timers, timer, when);
2077 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2078 timer = malloc(sizeof(*timer));
2080 timer_add(&timers, timer, when);
2081 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
2082 timer = malloc(sizeof(*timer));
2084 timer_add(&timers, timer, when);
2085 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
2086 timer = malloc(sizeof(*timer));
2088 timer_add(&timers, timer, when);
2089 timer_earliest(&timers, &when);
2090 free(timers_expire(&timers, when));
2091 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2092 timer = malloc(sizeof(*timer));
2094 timer_add(&timers, timer, when);
2095 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
2096 timer = malloc(sizeof(*timer));
2098 timer_add(&timers, timer, when);
2099 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2100 timer = malloc(sizeof(*timer));
2102 timer_add(&timers, timer, when);
2103 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2104 timer = malloc(sizeof(*timer));
2106 timer_add(&timers, timer, when);
2107 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2108 timer = malloc(sizeof(*timer));
2110 timer_add(&timers, timer, when);
2111 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2112 timer = malloc(sizeof(*timer));
2114 timer_add(&timers, timer, when);
2115 timer_earliest(&timers, &when);
2116 free(timers_expire(&timers, when));
2117 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2118 timer = malloc(sizeof(*timer));
2120 timer_add(&timers, timer, when);
2121 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
2122 timer = malloc(sizeof(*timer));
2124 timer_add(&timers, timer, when);
2125 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2126 timer = malloc(sizeof(*timer));
2128 timer_add(&timers, timer, when);
2129 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2130 timer = malloc(sizeof(*timer));
2132 timer_add(&timers, timer, when);
2133 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
2134 timer = malloc(sizeof(*timer));
2136 timer_add(&timers, timer, when);
2137 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2138 timer = malloc(sizeof(*timer));
2140 timer_add(&timers, timer, when);
2141 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
2142 timer = malloc(sizeof(*timer));
2144 timer_add(&timers, timer, when);
2145 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
2146 timer = malloc(sizeof(*timer));
2148 timer_add(&timers, timer, when);
2149 timer_earliest(&timers, &when);
2150 free(timers_expire(&timers, when));
2151 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2152 timer = malloc(sizeof(*timer));
2154 timer_add(&timers, timer, when);
2155 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
2156 timer = malloc(sizeof(*timer));
2158 timer_add(&timers, timer, when);
2159 when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000;
2160 timer = malloc(sizeof(*timer));
2162 timer_add(&timers, timer, when);
2163 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2164 timer = malloc(sizeof(*timer));
2166 timer_add(&timers, timer, when);
2167 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
2168 timer = malloc(sizeof(*timer));
2170 timer_add(&timers, timer, when);
2171 timer_earliest(&timers, &when);
2172 free(timers_expire(&timers, when));
2173 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2174 timer = malloc(sizeof(*timer));
2176 timer_add(&timers, timer, when);
2177 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2178 timer = malloc(sizeof(*timer));
2180 timer_add(&timers, timer, when);
2181 timer_earliest(&timers, &when);
2182 free(timers_expire(&timers, when));
2183 timer_earliest(&timers, &when);
2184 free(timers_expire(&timers, when));
2185 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2186 timer = malloc(sizeof(*timer));
2188 timer_add(&timers, timer, when);
2189 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2190 timer = malloc(sizeof(*timer));
2192 timer_add(&timers, timer, when);
2193 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2194 timer = malloc(sizeof(*timer));
2196 timer_add(&timers, timer, when);
2197 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2198 timer = malloc(sizeof(*timer));
2200 timer_add(&timers, timer, when);
2201 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2202 timer = malloc(sizeof(*timer));
2204 timer_add(&timers, timer, when);
2205 timer_earliest(&timers, &when);
2206 free(timers_expire(&timers, when));
2207 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
2208 timer = malloc(sizeof(*timer));
2210 timer_add(&timers, timer, when);
2211 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
2212 timer = malloc(sizeof(*timer));
2214 timer_add(&timers, timer, when);
2215 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2216 timer = malloc(sizeof(*timer));
2218 timer_add(&timers, timer, when);
2219 timer_earliest(&timers, &when);
2220 free(timers_expire(&timers, when));
2221 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
2222 timer = malloc(sizeof(*timer));
2224 timer_add(&timers, timer, when);
2225 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
2226 timer = malloc(sizeof(*timer));
2228 timer_add(&timers, timer, when);
2229 timer_earliest(&timers, &when);
2230 free(timers_expire(&timers, when));
2231 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
2232 timer = malloc(sizeof(*timer));
2234 timer_add(&timers, timer, when);
2235 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2236 timer = malloc(sizeof(*timer));
2238 timer_add(&timers, timer, when);
2239 when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
2240 timer = malloc(sizeof(*timer));
2242 timer_add(&timers, timer, when);
2243 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2244 timer = malloc(sizeof(*timer));
2246 timer_add(&timers, timer, when);
2247 timer_earliest(&timers, &when);
2248 free(timers_expire(&timers, when));
2249 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2250 timer = malloc(sizeof(*timer));
2252 timer_add(&timers, timer, when);
2253 timer_earliest(&timers, &when);
2254 free(timers_expire(&timers, when));
2255 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2256 timer = malloc(sizeof(*timer));
2258 timer_add(&timers, timer, when);
2259 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2260 timer = malloc(sizeof(*timer));
2262 timer_add(&timers, timer, when);
2263 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2264 timer = malloc(sizeof(*timer));
2266 timer_add(&timers, timer, when);
2267 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2268 timer = malloc(sizeof(*timer));
2270 timer_add(&timers, timer, when);
2271 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2272 timer = malloc(sizeof(*timer));
2274 timer_add(&timers, timer, when);
2275 timer_earliest(&timers, &when);
2276 free(timers_expire(&timers, when));
2277 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2278 timer = malloc(sizeof(*timer));
2280 timer_add(&timers, timer, when);
2281 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2282 timer = malloc(sizeof(*timer));
2284 timer_add(&timers, timer, when);
2285 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
2286 timer = malloc(sizeof(*timer));
2288 timer_add(&timers, timer, when);
2289 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2290 timer = malloc(sizeof(*timer));
2292 timer_add(&timers, timer, when);
2293 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2294 timer = malloc(sizeof(*timer));
2296 timer_add(&timers, timer, when);
2297 timer_earliest(&timers, &when);
2298 free(timers_expire(&timers, when));
2299 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2300 timer = malloc(sizeof(*timer));
2302 timer_add(&timers, timer, when);
2303 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2304 timer = malloc(sizeof(*timer));
2306 timer_add(&timers, timer, when);
2307 timer_earliest(&timers, &when);
2308 free(timers_expire(&timers, when));
2309 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2310 timer = malloc(sizeof(*timer));
2312 timer_add(&timers, timer, when);
2313 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2314 timer = malloc(sizeof(*timer));
2316 timer_add(&timers, timer, when);
2317 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2318 timer = malloc(sizeof(*timer));
2320 timer_add(&timers, timer, when);
2321 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2322 timer = malloc(sizeof(*timer));
2324 timer_add(&timers, timer, when);
2325 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
2326 timer = malloc(sizeof(*timer));
2328 timer_add(&timers, timer, when);
2329 timer_earliest(&timers, &when);
2330 free(timers_expire(&timers, when));
2331 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
2332 timer = malloc(sizeof(*timer));
2334 timer_add(&timers, timer, when);
2335 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2336 timer = malloc(sizeof(*timer));
2338 timer_add(&timers, timer, when);
2339 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2340 timer = malloc(sizeof(*timer));
2342 timer_add(&timers, timer, when);
2343 when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
2344 timer = malloc(sizeof(*timer));
2346 timer_add(&timers, timer, when);
2347 timer_earliest(&timers, &when);
2348 free(timers_expire(&timers, when));
2349 timer_earliest(&timers, &when);
2350 free(timers_expire(&timers, when));
2351 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2352 timer = malloc(sizeof(*timer));
2354 timer_add(&timers, timer, when);
2355 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2356 timer = malloc(sizeof(*timer));
2358 timer_add(&timers, timer, when);
2359 when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
2360 timer = malloc(sizeof(*timer));
2362 timer_add(&timers, timer, when);
2363 timer_earliest(&timers, &when);
2364 free(timers_expire(&timers, when));
2365 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2366 timer = malloc(sizeof(*timer));
2368 timer_add(&timers, timer, when);
2369 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2370 timer = malloc(sizeof(*timer));
2372 timer_add(&timers, timer, when);
2373 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2374 timer = malloc(sizeof(*timer));
2376 timer_add(&timers, timer, when);
2377 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2378 timer = malloc(sizeof(*timer));
2380 timer_add(&timers, timer, when);
2381 when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2382 timer = malloc(sizeof(*timer));
2384 timer_add(&timers, timer, when);
2385 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2386 timer = malloc(sizeof(*timer));
2388 timer_add(&timers, timer, when);
2389 timer_earliest(&timers, &when);
2390 free(timers_expire(&timers, when));
2391 when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000;
2392 timer = malloc(sizeof(*timer));
2394 timer_add(&timers, timer, when);
2395 when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000;
2396 timer = malloc(sizeof(*timer));
2398 timer_add(&timers, timer, when);
2399 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
2400 timer = malloc(sizeof(*timer));
2402 timer_add(&timers, timer, when);
2403 timer_earliest(&timers, &when);
2404 free(timers_expire(&timers, when));
2405 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2406 timer = malloc(sizeof(*timer));
2408 timer_add(&timers, timer, when);
2409 timer_earliest(&timers, &when);
2410 free(timers_expire(&timers, when));
2411 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2412 timer = malloc(sizeof(*timer));
2414 timer_add(&timers, timer, when);
2415 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
2416 timer = malloc(sizeof(*timer));
2418 timer_add(&timers, timer, when);
2419 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2420 timer = malloc(sizeof(*timer));
2422 timer_add(&timers, timer, when);
2423 timer_earliest(&timers, &when);
2424 free(timers_expire(&timers, when));
2425 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2426 timer = malloc(sizeof(*timer));
2428 timer_add(&timers, timer, when);
2429 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
2430 timer = malloc(sizeof(*timer));
2432 timer_add(&timers, timer, when);
2433 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2434 timer = malloc(sizeof(*timer));
2436 timer_add(&timers, timer, when);
2437 timer_earliest(&timers, &when);
2438 free(timers_expire(&timers, when));
2439 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
2440 timer = malloc(sizeof(*timer));
2442 timer_add(&timers, timer, when);
2443 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
2444 timer = malloc(sizeof(*timer));
2446 timer_add(&timers, timer, when);
2447 timer_earliest(&timers, &when);
2448 free(timers_expire(&timers, when));
2449 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2450 timer = malloc(sizeof(*timer));
2452 timer_add(&timers, timer, when);
2453 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
2454 timer = malloc(sizeof(*timer));
2456 timer_add(&timers, timer, when);
2457 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2458 timer = malloc(sizeof(*timer));
2460 timer_add(&timers, timer, when);
2461 timer_earliest(&timers, &when);
2462 free(timers_expire(&timers, when));
2463 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
2464 timer = malloc(sizeof(*timer));
2466 timer_add(&timers, timer, when);
2467 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2468 timer = malloc(sizeof(*timer));
2470 timer_add(&timers, timer, when);
2471 timer_earliest(&timers, &when);
2472 free(timers_expire(&timers, when));
2473 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
2474 timer = malloc(sizeof(*timer));
2476 timer_add(&timers, timer, when);
2477 timer_earliest(&timers, &when);
2478 free(timers_expire(&timers, when));
2479 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
2480 timer = malloc(sizeof(*timer));
2482 timer_add(&timers, timer, when);
2483 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2484 timer = malloc(sizeof(*timer));
2486 timer_add(&timers, timer, when);
2487 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
2488 timer = malloc(sizeof(*timer));
2490 timer_add(&timers, timer, when);
2491 timer_earliest(&timers, &when);
2492 free(timers_expire(&timers, when));
2493 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2494 timer = malloc(sizeof(*timer));
2496 timer_add(&timers, timer, when);
2497 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2498 timer = malloc(sizeof(*timer));
2500 timer_add(&timers, timer, when);
2501 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
2502 timer = malloc(sizeof(*timer));
2504 timer_add(&timers, timer, when);
2505 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2506 timer = malloc(sizeof(*timer));
2508 timer_add(&timers, timer, when);
2509 timer_earliest(&timers, &when);
2510 free(timers_expire(&timers, when));
2511 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
2512 timer = malloc(sizeof(*timer));
2514 timer_add(&timers, timer, when);
2515 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2516 timer = malloc(sizeof(*timer));
2518 timer_add(&timers, timer, when);
2519 timer_earliest(&timers, &when);
2520 free(timers_expire(&timers, when));
2521 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
2522 timer = malloc(sizeof(*timer));
2524 timer_add(&timers, timer, when);
2525 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2526 timer = malloc(sizeof(*timer));
2528 timer_add(&timers, timer, when);
2529 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2530 timer = malloc(sizeof(*timer));
2532 timer_add(&timers, timer, when);
2533 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2534 timer = malloc(sizeof(*timer));
2536 timer_add(&timers, timer, when);
2537 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
2538 timer = malloc(sizeof(*timer));
2540 timer_add(&timers, timer, when);
2541 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2542 timer = malloc(sizeof(*timer));
2544 timer_add(&timers, timer, when);
2545 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2546 timer = malloc(sizeof(*timer));
2548 timer_add(&timers, timer, when);
2549 timer_earliest(&timers, &when);
2550 free(timers_expire(&timers, when));
2551 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2552 timer = malloc(sizeof(*timer));
2554 timer_add(&timers, timer, when);
2555 timer_earliest(&timers, &when);
2556 free(timers_expire(&timers, when));
2557 when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000;
2558 timer = malloc(sizeof(*timer));
2560 timer_add(&timers, timer, when);
2561 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2562 timer = malloc(sizeof(*timer));
2564 timer_add(&timers, timer, when);
2565 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
2566 timer = malloc(sizeof(*timer));
2568 timer_add(&timers, timer, when);
2569 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
2570 timer = malloc(sizeof(*timer));
2572 timer_add(&timers, timer, when);
2573 timer_earliest(&timers, &when);
2574 free(timers_expire(&timers, when));
2575 timer_earliest(&timers, &when);
2576 free(timers_expire(&timers, when));
2577 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2578 timer = malloc(sizeof(*timer));
2580 timer_add(&timers, timer, when);
2581 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2582 timer = malloc(sizeof(*timer));
2584 timer_add(&timers, timer, when);
2585 when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
2586 timer = malloc(sizeof(*timer));
2588 timer_add(&timers, timer, when);
2589 timer_earliest(&timers, &when);
2590 free(timers_expire(&timers, when));
2591 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2592 timer = malloc(sizeof(*timer));
2594 timer_add(&timers, timer, when);
2595 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2596 timer = malloc(sizeof(*timer));
2598 timer_add(&timers, timer, when);
2599 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2600 timer = malloc(sizeof(*timer));
2602 timer_add(&timers, timer, when);
2603 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2604 timer = malloc(sizeof(*timer));
2606 timer_add(&timers, timer, when);
2607 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2608 timer = malloc(sizeof(*timer));
2610 timer_add(&timers, timer, when);
2611 timer_earliest(&timers, &when);
2612 free(timers_expire(&timers, when));
2613 timer_earliest(&timers, &when);
2614 free(timers_expire(&timers, when));
2615 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2616 timer = malloc(sizeof(*timer));
2618 timer_add(&timers, timer, when);
2619 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2620 timer = malloc(sizeof(*timer));
2622 timer_add(&timers, timer, when);
2623 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2624 timer = malloc(sizeof(*timer));
2626 timer_add(&timers, timer, when);
2627 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2628 timer = malloc(sizeof(*timer));
2630 timer_add(&timers, timer, when);
2631 timer_earliest(&timers, &when);
2632 free(timers_expire(&timers, when));
2633 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
2634 timer = malloc(sizeof(*timer));
2636 timer_add(&timers, timer, when);
2637 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
2638 timer = malloc(sizeof(*timer));
2640 timer_add(&timers, timer, when);
2641 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2642 timer = malloc(sizeof(*timer));
2644 timer_add(&timers, timer, when);
2645 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2646 timer = malloc(sizeof(*timer));
2648 timer_add(&timers, timer, when);
2649 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2650 timer = malloc(sizeof(*timer));
2652 timer_add(&timers, timer, when);
2653 timer_earliest(&timers, &when);
2654 free(timers_expire(&timers, when));
2655 timer_earliest(&timers, &when);
2656 free(timers_expire(&timers, when));
2657 timer_earliest(&timers, &when);
2658 free(timers_expire(&timers, when));
2659 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
2660 timer = malloc(sizeof(*timer));
2662 timer_add(&timers, timer, when);
2663 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2664 timer = malloc(sizeof(*timer));
2666 timer_add(&timers, timer, when);
2667 timer_earliest(&timers, &when);
2668 free(timers_expire(&timers, when));
2669 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2670 timer = malloc(sizeof(*timer));
2672 timer_add(&timers, timer, when);
2673 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2674 timer = malloc(sizeof(*timer));
2676 timer_add(&timers, timer, when);
2677 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2678 timer = malloc(sizeof(*timer));
2680 timer_add(&timers, timer, when);
2681 timer_earliest(&timers, &when);
2682 free(timers_expire(&timers, when));
2683 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
2684 timer = malloc(sizeof(*timer));
2686 timer_add(&timers, timer, when);
2687 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
2688 timer = malloc(sizeof(*timer));
2690 timer_add(&timers, timer, when);
2691 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2692 timer = malloc(sizeof(*timer));
2694 timer_add(&timers, timer, when);
2695 timer_earliest(&timers, &when);
2696 free(timers_expire(&timers, when));
2697 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2698 timer = malloc(sizeof(*timer));
2700 timer_add(&timers, timer, when);
2701 when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000;
2702 timer = malloc(sizeof(*timer));
2704 timer_add(&timers, timer, when);
2705 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
2706 timer = malloc(sizeof(*timer));
2708 timer_add(&timers, timer, when);
2709 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
2710 timer = malloc(sizeof(*timer));
2712 timer_add(&timers, timer, when);
2713 timer_earliest(&timers, &when);
2714 free(timers_expire(&timers, when));
2715 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2716 timer = malloc(sizeof(*timer));
2718 timer_add(&timers, timer, when);
2719 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2720 timer = malloc(sizeof(*timer));
2722 timer_add(&timers, timer, when);
2723 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2724 timer = malloc(sizeof(*timer));
2726 timer_add(&timers, timer, when);
2727 timer_earliest(&timers, &when);
2728 free(timers_expire(&timers, when));
2729 timer_earliest(&timers, &when);
2730 free(timers_expire(&timers, when));
2731 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2732 timer = malloc(sizeof(*timer));
2734 timer_add(&timers, timer, when);
2735 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
2736 timer = malloc(sizeof(*timer));
2738 timer_add(&timers, timer, when);
2739 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2740 timer = malloc(sizeof(*timer));
2742 timer_add(&timers, timer, when);
2743 timer_earliest(&timers, &when);
2744 free(timers_expire(&timers, when));
2745 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2746 timer = malloc(sizeof(*timer));
2748 timer_add(&timers, timer, when);
2749 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
2750 timer = malloc(sizeof(*timer));
2752 timer_add(&timers, timer, when);
2753 timer_earliest(&timers, &when);
2754 free(timers_expire(&timers, when));
2755 timer_earliest(&timers, &when);
2756 free(timers_expire(&timers, when));
2757 timer_earliest(&timers, &when);
2758 free(timers_expire(&timers, when));
2759 timer_earliest(&timers, &when);
2760 free(timers_expire(&timers, when));
2761 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2762 timer = malloc(sizeof(*timer));
2764 timer_add(&timers, timer, when);
2765 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2766 timer = malloc(sizeof(*timer));
2768 timer_add(&timers, timer, when);
2769 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2770 timer = malloc(sizeof(*timer));
2772 timer_add(&timers, timer, when);
2773 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
2774 timer = malloc(sizeof(*timer));
2776 timer_add(&timers, timer, when);
2777 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
2778 timer = malloc(sizeof(*timer));
2780 timer_add(&timers, timer, when);
2781 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2782 timer = malloc(sizeof(*timer));
2784 timer_add(&timers, timer, when);
2785 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2786 timer = malloc(sizeof(*timer));
2788 timer_add(&timers, timer, when);
2789 timer_earliest(&timers, &when);
2790 free(timers_expire(&timers, when));
2791 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2792 timer = malloc(sizeof(*timer));
2794 timer_add(&timers, timer, when);
2795 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2796 timer = malloc(sizeof(*timer));
2798 timer_add(&timers, timer, when);
2799 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
2800 timer = malloc(sizeof(*timer));
2802 timer_add(&timers, timer, when);
2803 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2804 timer = malloc(sizeof(*timer));
2806 timer_add(&timers, timer, when);
2807 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
2808 timer = malloc(sizeof(*timer));
2810 timer_add(&timers, timer, when);
2811 timer_earliest(&timers, &when);
2812 free(timers_expire(&timers, when));
2813 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2814 timer = malloc(sizeof(*timer));
2816 timer_add(&timers, timer, when);
2817 timer_earliest(&timers, &when);
2818 free(timers_expire(&timers, when));
2819 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2820 timer = malloc(sizeof(*timer));
2822 timer_add(&timers, timer, when);
2823 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2824 timer = malloc(sizeof(*timer));
2826 timer_add(&timers, timer, when);
2827 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2828 timer = malloc(sizeof(*timer));
2830 timer_add(&timers, timer, when);
2831 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2832 timer = malloc(sizeof(*timer));
2834 timer_add(&timers, timer, when);
2835 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
2836 timer = malloc(sizeof(*timer));
2838 timer_add(&timers, timer, when);
2839 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2840 timer = malloc(sizeof(*timer));
2842 timer_add(&timers, timer, when);
2843 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2844 timer = malloc(sizeof(*timer));
2846 timer_add(&timers, timer, when);
2847 timer_earliest(&timers, &when);
2848 free(timers_expire(&timers, when));
2849 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2850 timer = malloc(sizeof(*timer));
2852 timer_add(&timers, timer, when);
2853 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2854 timer = malloc(sizeof(*timer));
2856 timer_add(&timers, timer, when);
2857 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
2858 timer = malloc(sizeof(*timer));
2860 timer_add(&timers, timer, when);
2861 when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
2862 timer = malloc(sizeof(*timer));
2864 timer_add(&timers, timer, when);
2865 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2866 timer = malloc(sizeof(*timer));
2868 timer_add(&timers, timer, when);
2869 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2870 timer = malloc(sizeof(*timer));
2872 timer_add(&timers, timer, when);
2873 timer_earliest(&timers, &when);
2874 free(timers_expire(&timers, when));
2875 timer_earliest(&timers, &when);
2876 free(timers_expire(&timers, when));
2877 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2878 timer = malloc(sizeof(*timer));
2880 timer_add(&timers, timer, when);
2881 timer_earliest(&timers, &when);
2882 free(timers_expire(&timers, when));
2883 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
2884 timer = malloc(sizeof(*timer));
2886 timer_add(&timers, timer, when);
2887 timer_earliest(&timers, &when);
2888 free(timers_expire(&timers, when));
2889 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
2890 timer = malloc(sizeof(*timer));
2892 timer_add(&timers, timer, when);
2893 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2894 timer = malloc(sizeof(*timer));
2896 timer_add(&timers, timer, when);
2897 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
2898 timer = malloc(sizeof(*timer));
2900 timer_add(&timers, timer, when);
2901 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2902 timer = malloc(sizeof(*timer));
2904 timer_add(&timers, timer, when);
2905 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
2906 timer = malloc(sizeof(*timer));
2908 timer_add(&timers, timer, when);
2909 timer_earliest(&timers, &when);
2910 free(timers_expire(&timers, when));
2911 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2912 timer = malloc(sizeof(*timer));
2914 timer_add(&timers, timer, when);
2915 timer_earliest(&timers, &when);
2916 free(timers_expire(&timers, when));
2917 when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
2918 timer = malloc(sizeof(*timer));
2920 timer_add(&timers, timer, when);
2921 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2922 timer = malloc(sizeof(*timer));
2924 timer_add(&timers, timer, when);
2925 when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000;
2926 timer = malloc(sizeof(*timer));
2928 timer_add(&timers, timer, when);
2929 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
2930 timer = malloc(sizeof(*timer));
2932 timer_add(&timers, timer, when);
2933 timer_earliest(&timers, &when);
2934 free(timers_expire(&timers, when));
2935 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2936 timer = malloc(sizeof(*timer));
2938 timer_add(&timers, timer, when);
2939 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2940 timer = malloc(sizeof(*timer));
2942 timer_add(&timers, timer, when);
2943 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2944 timer = malloc(sizeof(*timer));
2946 timer_add(&timers, timer, when);
2947 timer_earliest(&timers, &when);
2948 free(timers_expire(&timers, when));
2949 timer_earliest(&timers, &when);
2950 free(timers_expire(&timers, when));
2951 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2952 timer = malloc(sizeof(*timer));
2954 timer_add(&timers, timer, when);
2955 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2956 timer = malloc(sizeof(*timer));
2958 timer_add(&timers, timer, when);
2959 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2960 timer = malloc(sizeof(*timer));
2962 timer_add(&timers, timer, when);
2963 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2964 timer = malloc(sizeof(*timer));
2966 timer_add(&timers, timer, when);
2967 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2968 timer = malloc(sizeof(*timer));
2970 timer_add(&timers, timer, when);
2971 timer_earliest(&timers, &when);
2972 free(timers_expire(&timers, when));
2973 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
2974 timer = malloc(sizeof(*timer));
2976 timer_add(&timers, timer, when);
2977 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2978 timer = malloc(sizeof(*timer));
2980 timer_add(&timers, timer, when);
2981 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
2982 timer = malloc(sizeof(*timer));
2984 timer_add(&timers, timer, when);
2985 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
2986 timer = malloc(sizeof(*timer));
2988 timer_add(&timers, timer, when);
2989 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2990 timer = malloc(sizeof(*timer));
2992 timer_add(&timers, timer, when);
2993 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2994 timer = malloc(sizeof(*timer));
2996 timer_add(&timers, timer, when);
2997 timer_earliest(&timers, &when);
2998 free(timers_expire(&timers, when));
2999 timer_earliest(&timers, &when);
3000 free(timers_expire(&timers, when));
3001 timer_earliest(&timers, &when);
3002 free(timers_expire(&timers, when));
3003 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3004 timer = malloc(sizeof(*timer));
3006 timer_add(&timers, timer, when);
3007 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3008 timer = malloc(sizeof(*timer));
3010 timer_add(&timers, timer, when);
3011 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3012 timer = malloc(sizeof(*timer));
3014 timer_add(&timers, timer, when);
3015 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3016 timer = malloc(sizeof(*timer));
3018 timer_add(&timers, timer, when);
3019 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3020 timer = malloc(sizeof(*timer));
3022 timer_add(&timers, timer, when);
3023 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
3024 timer = malloc(sizeof(*timer));
3026 timer_add(&timers, timer, when);
3027 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
3028 timer = malloc(sizeof(*timer));
3030 timer_add(&timers, timer, when);
3031 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3032 timer = malloc(sizeof(*timer));
3034 timer_add(&timers, timer, when);
3035 timer_earliest(&timers, &when);
3036 free(timers_expire(&timers, when));
3037 timer_earliest(&timers, &when);
3038 free(timers_expire(&timers, when));
3039 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3040 timer = malloc(sizeof(*timer));
3042 timer_add(&timers, timer, when);
3043 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3044 timer = malloc(sizeof(*timer));
3046 timer_add(&timers, timer, when);
3047 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3048 timer = malloc(sizeof(*timer));
3050 timer_add(&timers, timer, when);
3051 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3052 timer = malloc(sizeof(*timer));
3054 timer_add(&timers, timer, when);
3055 timer_earliest(&timers, &when);
3056 free(timers_expire(&timers, when));
3057 timer_earliest(&timers, &when);
3058 free(timers_expire(&timers, when));
3059 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3060 timer = malloc(sizeof(*timer));
3062 timer_add(&timers, timer, when);
3063 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
3064 timer = malloc(sizeof(*timer));
3066 timer_add(&timers, timer, when);
3067 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3068 timer = malloc(sizeof(*timer));
3070 timer_add(&timers, timer, when);
3071 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3072 timer = malloc(sizeof(*timer));
3074 timer_add(&timers, timer, when);
3075 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3076 timer = malloc(sizeof(*timer));
3078 timer_add(&timers, timer, when);
3079 timer_earliest(&timers, &when);
3080 free(timers_expire(&timers, when));
3081 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3082 timer = malloc(sizeof(*timer));
3084 timer_add(&timers, timer, when);
3085 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3086 timer = malloc(sizeof(*timer));
3088 timer_add(&timers, timer, when);
3089 timer_earliest(&timers, &when);
3090 free(timers_expire(&timers, when));
3091 timer_earliest(&timers, &when);
3092 free(timers_expire(&timers, when));
3093 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3094 timer = malloc(sizeof(*timer));
3096 timer_add(&timers, timer, when);
3097 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
3098 timer = malloc(sizeof(*timer));
3100 timer_add(&timers, timer, when);
3101 timer_earliest(&timers, &when);
3102 free(timers_expire(&timers, when));
3103 timer_earliest(&timers, &when);
3104 free(timers_expire(&timers, when));
3105 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
3106 timer = malloc(sizeof(*timer));
3108 timer_add(&timers, timer, when);
3109 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3110 timer = malloc(sizeof(*timer));
3112 timer_add(&timers, timer, when);
3113 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
3114 timer = malloc(sizeof(*timer));
3116 timer_add(&timers, timer, when);
3117 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3118 timer = malloc(sizeof(*timer));
3120 timer_add(&timers, timer, when);
3121 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3122 timer = malloc(sizeof(*timer));
3124 timer_add(&timers, timer, when);
3125 timer_earliest(&timers, &when);
3126 free(timers_expire(&timers, when));
3127 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3128 timer = malloc(sizeof(*timer));
3130 timer_add(&timers, timer, when);
3131 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3132 timer = malloc(sizeof(*timer));
3134 timer_add(&timers, timer, when);
3135 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3136 timer = malloc(sizeof(*timer));
3138 timer_add(&timers, timer, when);
3139 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3140 timer = malloc(sizeof(*timer));
3142 timer_add(&timers, timer, when);
3143 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
3144 timer = malloc(sizeof(*timer));
3146 timer_add(&timers, timer, when);
3147 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3148 timer = malloc(sizeof(*timer));
3150 timer_add(&timers, timer, when);
3151 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
3152 timer = malloc(sizeof(*timer));
3154 timer_add(&timers, timer, when);
3155 timer_earliest(&timers, &when);
3156 free(timers_expire(&timers, when));
3157 timer_earliest(&timers, &when);
3158 free(timers_expire(&timers, when));
3159 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3160 timer = malloc(sizeof(*timer));
3162 timer_add(&timers, timer, when);
3163 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
3164 timer = malloc(sizeof(*timer));
3166 timer_add(&timers, timer, when);
3167 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3168 timer = malloc(sizeof(*timer));
3170 timer_add(&timers, timer, when);
3171 timer_earliest(&timers, &when);
3172 free(timers_expire(&timers, when));
3173 timer_earliest(&timers, &when);
3174 free(timers_expire(&timers, when));
3175 timer_earliest(&timers, &when);
3176 free(timers_expire(&timers, when));
3177 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3178 timer = malloc(sizeof(*timer));
3180 timer_add(&timers, timer, when);
3181 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3182 timer = malloc(sizeof(*timer));
3184 timer_add(&timers, timer, when);
3185 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
3186 timer = malloc(sizeof(*timer));
3188 timer_add(&timers, timer, when);
3189 timer_earliest(&timers, &when);
3190 free(timers_expire(&timers, when));
3191 timer_earliest(&timers, &when);
3192 free(timers_expire(&timers, when));
3193 timer_earliest(&timers, &when);
3194 free(timers_expire(&timers, when));
3195 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
3196 timer = malloc(sizeof(*timer));
3198 timer_add(&timers, timer, when);
3199 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
3200 timer = malloc(sizeof(*timer));
3202 timer_add(&timers, timer, when);
3203 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3204 timer = malloc(sizeof(*timer));
3206 timer_add(&timers, timer, when);
3207 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3208 timer = malloc(sizeof(*timer));
3210 timer_add(&timers, timer, when);
3211 when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
3212 timer = malloc(sizeof(*timer));
3214 timer_add(&timers, timer, when);
3215 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3216 timer = malloc(sizeof(*timer));
3218 timer_add(&timers, timer, when);
3219 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3220 timer = malloc(sizeof(*timer));
3222 timer_add(&timers, timer, when);
3223 timer_earliest(&timers, &when);
3224 free(timers_expire(&timers, when));
3225 timer_earliest(&timers, &when);
3226 free(timers_expire(&timers, when));
3227 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3228 timer = malloc(sizeof(*timer));
3230 timer_add(&timers, timer, when);
3231 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3232 timer = malloc(sizeof(*timer));
3234 timer_add(&timers, timer, when);
3235 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
3236 timer = malloc(sizeof(*timer));
3238 timer_add(&timers, timer, when);
3239 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3240 timer = malloc(sizeof(*timer));
3242 timer_add(&timers, timer, when);
3243 timer_earliest(&timers, &when);
3244 free(timers_expire(&timers, when));
3245 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
3246 timer = malloc(sizeof(*timer));
3248 timer_add(&timers, timer, when);
3249 timer_earliest(&timers, &when);
3250 free(timers_expire(&timers, when));
3251 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
3252 timer = malloc(sizeof(*timer));
3254 timer_add(&timers, timer, when);
3255 timer_earliest(&timers, &when);
3256 free(timers_expire(&timers, when));
3257 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
3258 timer = malloc(sizeof(*timer));
3260 timer_add(&timers, timer, when);
3261 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3262 timer = malloc(sizeof(*timer));
3264 timer_add(&timers, timer, when);
3265 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3266 timer = malloc(sizeof(*timer));
3268 timer_add(&timers, timer, when);
3269 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3270 timer = malloc(sizeof(*timer));
3272 timer_add(&timers, timer, when);
3273 timer_earliest(&timers, &when);
3274 free(timers_expire(&timers, when));
3275 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
3276 timer = malloc(sizeof(*timer));
3278 timer_add(&timers, timer, when);
3279 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
3280 timer = malloc(sizeof(*timer));
3282 timer_add(&timers, timer, when);
3283 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3284 timer = malloc(sizeof(*timer));
3286 timer_add(&timers, timer, when);
3287 timer_earliest(&timers, &when);
3288 free(timers_expire(&timers, when));
3289 timer_earliest(&timers, &when);
3290 free(timers_expire(&timers, when));
3291 timer_earliest(&timers, &when);
3292 free(timers_expire(&timers, when));
3293 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3294 timer = malloc(sizeof(*timer));
3296 timer_add(&timers, timer, when);
3297 timer_earliest(&timers, &when);
3298 free(timers_expire(&timers, when));
3299 timer_earliest(&timers, &when);
3300 free(timers_expire(&timers, when));
3301 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
3302 timer = malloc(sizeof(*timer));
3304 timer_add(&timers, timer, when);
3305 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3306 timer = malloc(sizeof(*timer));
3308 timer_add(&timers, timer, when);
3309 when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000;
3310 timer = malloc(sizeof(*timer));
3312 timer_add(&timers, timer, when);
3313 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
3314 timer = malloc(sizeof(*timer));
3316 timer_add(&timers, timer, when);
3317 timer_earliest(&timers, &when);
3318 free(timers_expire(&timers, when));
3319 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
3320 timer = malloc(sizeof(*timer));
3322 timer_add(&timers, timer, when);
3323 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3324 timer = malloc(sizeof(*timer));
3326 timer_add(&timers, timer, when);
3327 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
3328 timer = malloc(sizeof(*timer));
3330 timer_add(&timers, timer, when);
3331 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3332 timer = malloc(sizeof(*timer));
3334 timer_add(&timers, timer, when);
3335 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3336 timer = malloc(sizeof(*timer));
3338 timer_add(&timers, timer, when);
3339 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
3340 timer = malloc(sizeof(*timer));
3342 timer_add(&timers, timer, when);
3343 when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
3344 timer = malloc(sizeof(*timer));
3346 timer_add(&timers, timer, when);
3347 timer_earliest(&timers, &when);
3348 free(timers_expire(&timers, when));
3349 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3350 timer = malloc(sizeof(*timer));
3352 timer_add(&timers, timer, when);
3353 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3354 timer = malloc(sizeof(*timer));
3356 timer_add(&timers, timer, when);
3357 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3358 timer = malloc(sizeof(*timer));
3360 timer_add(&timers, timer, when);
3361 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3362 timer = malloc(sizeof(*timer));
3364 timer_add(&timers, timer, when);
3365 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3366 timer = malloc(sizeof(*timer));
3368 timer_add(&timers, timer, when);
3369 when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
3370 timer = malloc(sizeof(*timer));
3372 timer_add(&timers, timer, when);
3373 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
3374 timer = malloc(sizeof(*timer));
3376 timer_add(&timers, timer, when);
3377 timer_earliest(&timers, &when);
3378 free(timers_expire(&timers, when));
3379 timer_earliest(&timers, &when);
3380 free(timers_expire(&timers, when));
3381 timer_earliest(&timers, &when);
3382 free(timers_expire(&timers, when));
3383 when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
3384 timer = malloc(sizeof(*timer));
3386 timer_add(&timers, timer, when);
3387 timer_earliest(&timers, &when);
3388 free(timers_expire(&timers, when));
3389 timer_earliest(&timers, &when);
3390 free(timers_expire(&timers, when));
3391 timer_earliest(&timers, &when);
3392 free(timers_expire(&timers, when));
3393 timer_earliest(&timers, &when);
3394 free(timers_expire(&timers, when));
3395 timer_earliest(&timers, &when);
3396 free(timers_expire(&timers, when));
3397 timer_earliest(&timers, &when);
3398 free(timers_expire(&timers, when));
3399 timer_earliest(&timers, &when);
3400 free(timers_expire(&timers, when));
3401 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
3402 timer = malloc(sizeof(*timer));
3404 timer_add(&timers, timer, when);
3405 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
3406 timer = malloc(sizeof(*timer));
3408 timer_add(&timers, timer, when);
3409 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3410 timer = malloc(sizeof(*timer));
3412 timer_add(&timers, timer, when);
3413 timer_earliest(&timers, &when);
3414 free(timers_expire(&timers, when));
3415 timer_earliest(&timers, &when);
3416 free(timers_expire(&timers, when));
3417 timer_earliest(&timers, &when);
3418 free(timers_expire(&timers, when));
3419 timer_earliest(&timers, &when);
3420 free(timers_expire(&timers, when));
3421 timer_earliest(&timers, &when);
3422 free(timers_expire(&timers, when));
3423 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3424 timer = malloc(sizeof(*timer));
3426 timer_add(&timers, timer, when);
3427 when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000;
3428 timer = malloc(sizeof(*timer));
3430 timer_add(&timers, timer, when);
3431 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3432 timer = malloc(sizeof(*timer));
3434 timer_add(&timers, timer, when);
3435 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3436 timer = malloc(sizeof(*timer));
3438 timer_add(&timers, timer, when);
3439 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3440 timer = malloc(sizeof(*timer));
3442 timer_add(&timers, timer, when);
3443 timer_earliest(&timers, &when);
3444 free(timers_expire(&timers, when));
3445 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3446 timer = malloc(sizeof(*timer));
3448 timer_add(&timers, timer, when);
3449 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
3450 timer = malloc(sizeof(*timer));
3452 timer_add(&timers, timer, when);
3453 timer_earliest(&timers, &when);
3454 free(timers_expire(&timers, when));
3455 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
3456 timer = malloc(sizeof(*timer));
3458 timer_add(&timers, timer, when);
3459 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
3460 timer = malloc(sizeof(*timer));
3462 timer_add(&timers, timer, when);
3463 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
3464 timer = malloc(sizeof(*timer));
3466 timer_add(&timers, timer, when);
3467 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3468 timer = malloc(sizeof(*timer));
3470 timer_add(&timers, timer, when);
3471 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3472 timer = malloc(sizeof(*timer));
3474 timer_add(&timers, timer, when);
3475 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3476 timer = malloc(sizeof(*timer));
3478 timer_add(&timers, timer, when);
3479 timer_earliest(&timers, &when);
3480 free(timers_expire(&timers, when));
3481 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3482 timer = malloc(sizeof(*timer));
3484 timer_add(&timers, timer, when);
3485 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
3486 timer = malloc(sizeof(*timer));
3488 timer_add(&timers, timer, when);
3489 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
3490 timer = malloc(sizeof(*timer));
3492 timer_add(&timers, timer, when);
3493 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3494 timer = malloc(sizeof(*timer));
3496 timer_add(&timers, timer, when);
3497 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
3498 timer = malloc(sizeof(*timer));
3500 timer_add(&timers, timer, when);
3501 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3502 timer = malloc(sizeof(*timer));
3504 timer_add(&timers, timer, when);
3505 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
3506 timer = malloc(sizeof(*timer));
3508 timer_add(&timers, timer, when);
3509 timer_earliest(&timers, &when);
3510 free(timers_expire(&timers, when));
3511 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
3512 timer = malloc(sizeof(*timer));
3514 timer_add(&timers, timer, when);
3515 when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
3516 timer = malloc(sizeof(*timer));
3518 timer_add(&timers, timer, when);
3519 timer_earliest(&timers, &when);
3520 free(timers_expire(&timers, when));
3521 timer_earliest(&timers, &when);
3522 free(timers_expire(&timers, when));
3523 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
3524 timer = malloc(sizeof(*timer));
3526 timer_add(&timers, timer, when);
3527 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3528 timer = malloc(sizeof(*timer));
3530 timer_add(&timers, timer, when);
3531 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
3532 timer = malloc(sizeof(*timer));
3534 timer_add(&timers, timer, when);
3535 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3536 timer = malloc(sizeof(*timer));
3538 timer_add(&timers, timer, when);
3539 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
3540 timer = malloc(sizeof(*timer));
3542 timer_add(&timers, timer, when);
3543 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
3544 timer = malloc(sizeof(*timer));
3546 timer_add(&timers, timer, when);
3547 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3548 timer = malloc(sizeof(*timer));
3550 timer_add(&timers, timer, when);
3551 timer_earliest(&timers, &when);
3552 free(timers_expire(&timers, when));
3553 timer_earliest(&timers, &when);
3554 free(timers_expire(&timers, when));
3555 timer_earliest(&timers, &when);
3556 free(timers_expire(&timers, when));
3557 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
3558 timer = malloc(sizeof(*timer));
3560 timer_add(&timers, timer, when);
3561 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3562 timer = malloc(sizeof(*timer));
3564 timer_add(&timers, timer, when);
3565 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
3566 timer = malloc(sizeof(*timer));
3568 timer_add(&timers, timer, when);
3569 timer_earliest(&timers, &when);
3570 free(timers_expire(&timers, when));
3571 timer_earliest(&timers, &when);
3572 free(timers_expire(&timers, when));
3573 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3574 timer = malloc(sizeof(*timer));
3576 timer_add(&timers, timer, when);
3577 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3578 timer = malloc(sizeof(*timer));
3580 timer_add(&timers, timer, when);
3581 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3582 timer = malloc(sizeof(*timer));
3584 timer_add(&timers, timer, when);
3585 timer_earliest(&timers, &when);
3586 free(timers_expire(&timers, when));
3587 timer_earliest(&timers, &when);
3588 free(timers_expire(&timers, when));
3589 timer_earliest(&timers, &when);
3590 free(timers_expire(&timers, when));
3591 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3592 timer = malloc(sizeof(*timer));
3594 timer_add(&timers, timer, when);
3595 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
3596 timer = malloc(sizeof(*timer));
3598 timer_add(&timers, timer, when);
3599 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3600 timer = malloc(sizeof(*timer));
3602 timer_add(&timers, timer, when);
3603 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
3604 timer = malloc(sizeof(*timer));
3606 timer_add(&timers, timer, when);
3607 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3608 timer = malloc(sizeof(*timer));
3610 timer_add(&timers, timer, when);
3611 timer_earliest(&timers, &when);
3612 free(timers_expire(&timers, when));
3613 timer_earliest(&timers, &when);
3614 free(timers_expire(&timers, when));
3615 timer_earliest(&timers, &when);
3616 free(timers_expire(&timers, when));
3617 timer_earliest(&timers, &when);
3618 free(timers_expire(&timers, when));
3619 timer_earliest(&timers, &when);
3620 free(timers_expire(&timers, when));
3621 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3622 timer = malloc(sizeof(*timer));
3624 timer_add(&timers, timer, when);
3625 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
3626 timer = malloc(sizeof(*timer));
3628 timer_add(&timers, timer, when);
3629 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3630 timer = malloc(sizeof(*timer));
3632 timer_add(&timers, timer, when);
3633 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
3634 timer = malloc(sizeof(*timer));
3636 timer_add(&timers, timer, when);
3637 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
3638 timer = malloc(sizeof(*timer));
3640 timer_add(&timers, timer, when);
3641 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3642 timer = malloc(sizeof(*timer));
3644 timer_add(&timers, timer, when);
3645 timer_earliest(&timers, &when);
3646 free(timers_expire(&timers, when));
3647 timer_earliest(&timers, &when);
3648 free(timers_expire(&timers, when));
3649 timer_earliest(&timers, &when);
3650 free(timers_expire(&timers, when));
3651 timer_earliest(&timers, &when);
3652 free(timers_expire(&timers, when));
3653 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3654 timer = malloc(sizeof(*timer));
3656 timer_add(&timers, timer, when);
3657 timer_earliest(&timers, &when);
3658 free(timers_expire(&timers, when));
3659 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3660 timer = malloc(sizeof(*timer));
3662 timer_add(&timers, timer, when);
3663 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3664 timer = malloc(sizeof(*timer));
3666 timer_add(&timers, timer, when);
3667 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3668 timer = malloc(sizeof(*timer));
3670 timer_add(&timers, timer, when);
3671 timer_earliest(&timers, &when);
3672 free(timers_expire(&timers, when));
3673 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3674 timer = malloc(sizeof(*timer));
3676 timer_add(&timers, timer, when);
3677 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3678 timer = malloc(sizeof(*timer));
3680 timer_add(&timers, timer, when);
3681 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
3682 timer = malloc(sizeof(*timer));
3684 timer_add(&timers, timer, when);
3685 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3686 timer = malloc(sizeof(*timer));
3688 timer_add(&timers, timer, when);
3689 timer_earliest(&timers, &when);
3690 free(timers_expire(&timers, when));
3691 timer_earliest(&timers, &when);
3692 free(timers_expire(&timers, when));
3693 timer_earliest(&timers, &when);
3694 free(timers_expire(&timers, when));
3695 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
3696 timer = malloc(sizeof(*timer));
3698 timer_add(&timers, timer, when);
3699 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
3700 timer = malloc(sizeof(*timer));
3702 timer_add(&timers, timer, when);
3703 timer_earliest(&timers, &when);
3704 free(timers_expire(&timers, when));
3705 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3706 timer = malloc(sizeof(*timer));
3708 timer_add(&timers, timer, when);
3709 timer_earliest(&timers, &when);
3710 free(timers_expire(&timers, when));
3711 timer_earliest(&timers, &when);
3712 free(timers_expire(&timers, when));
3713 timer_earliest(&timers, &when);
3714 free(timers_expire(&timers, when));
3715 timer_earliest(&timers, &when);
3716 free(timers_expire(&timers, when));
3717 timer_earliest(&timers, &when);
3718 free(timers_expire(&timers, when));
3719 timer_earliest(&timers, &when);
3720 free(timers_expire(&timers, when));
3721 timer_earliest(&timers, &when);
3722 free(timers_expire(&timers, when));
3723 timer_earliest(&timers, &when);
3724 free(timers_expire(&timers, when));
3725 timer_earliest(&timers, &when);
3726 free(timers_expire(&timers, when));
3727 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
3728 timer = malloc(sizeof(*timer));
3730 timer_add(&timers, timer, when);
3731 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3732 timer = malloc(sizeof(*timer));
3734 timer_add(&timers, timer, when);
3735 timer_earliest(&timers, &when);
3736 free(timers_expire(&timers, when));
3737 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3738 timer = malloc(sizeof(*timer));
3740 timer_add(&timers, timer, when);
3741 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
3742 timer = malloc(sizeof(*timer));
3744 timer_add(&timers, timer, when);
3745 timer_earliest(&timers, &when);
3746 free(timers_expire(&timers, when));
3747 timer_earliest(&timers, &when);
3748 free(timers_expire(&timers, when));
3749 timer_earliest(&timers, &when);
3750 free(timers_expire(&timers, when));
3751 timer_earliest(&timers, &when);
3752 free(timers_expire(&timers, when));
3753 timer_earliest(&timers, &when);
3754 free(timers_expire(&timers, when));
3755 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
3756 timer = malloc(sizeof(*timer));
3758 timer_add(&timers, timer, when);
3759 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
3760 timer = malloc(sizeof(*timer));
3762 timer_add(&timers, timer, when);
3763 timer_earliest(&timers, &when);
3764 free(timers_expire(&timers, when));
3765 timer_earliest(&timers, &when);
3766 free(timers_expire(&timers, when));
3767 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3768 timer = malloc(sizeof(*timer));
3770 timer_add(&timers, timer, when);
3771 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3772 timer = malloc(sizeof(*timer));
3774 timer_add(&timers, timer, when);
3775 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3776 timer = malloc(sizeof(*timer));
3778 timer_add(&timers, timer, when);
3779 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
3780 timer = malloc(sizeof(*timer));
3782 timer_add(&timers, timer, when);
3783 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3784 timer = malloc(sizeof(*timer));
3786 timer_add(&timers, timer, when);
3787 timer_earliest(&timers, &when);
3788 free(timers_expire(&timers, when));
3789 timer_earliest(&timers, &when);
3790 free(timers_expire(&timers, when));
3791 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3792 timer = malloc(sizeof(*timer));
3794 timer_add(&timers, timer, when);
3795 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3796 timer = malloc(sizeof(*timer));
3798 timer_add(&timers, timer, when);
3799 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3800 timer = malloc(sizeof(*timer));
3802 timer_add(&timers, timer, when);
3803 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3804 timer = malloc(sizeof(*timer));
3806 timer_add(&timers, timer, when);
3807 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3808 timer = malloc(sizeof(*timer));
3810 timer_add(&timers, timer, when);
3811 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3812 timer = malloc(sizeof(*timer));
3814 timer_add(&timers, timer, when);
3815 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3816 timer = malloc(sizeof(*timer));
3818 timer_add(&timers, timer, when);
3819 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
3820 timer = malloc(sizeof(*timer));
3822 timer_add(&timers, timer, when);
3823 timer_earliest(&timers, &when);
3824 free(timers_expire(&timers, when));
3825 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3826 timer = malloc(sizeof(*timer));
3828 timer_add(&timers, timer, when);
3829 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
3830 timer = malloc(sizeof(*timer));
3832 timer_add(&timers, timer, when);
3833 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3834 timer = malloc(sizeof(*timer));
3836 timer_add(&timers, timer, when);
3837 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
3838 timer = malloc(sizeof(*timer));
3840 timer_add(&timers, timer, when);
3841 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
3842 timer = malloc(sizeof(*timer));
3844 timer_add(&timers, timer, when);
3845 timer_earliest(&timers, &when);
3846 free(timers_expire(&timers, when));
3847 timer_earliest(&timers, &when);
3848 free(timers_expire(&timers, when));
3849 timer_earliest(&timers, &when);
3850 free(timers_expire(&timers, when));
3851 timer_earliest(&timers, &when);
3852 free(timers_expire(&timers, when));
3853 timer_earliest(&timers, &when);
3854 free(timers_expire(&timers, when));
3855 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
3856 timer = malloc(sizeof(*timer));
3858 timer_add(&timers, timer, when);
3859 when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
3860 timer = malloc(sizeof(*timer));
3862 timer_add(&timers, timer, when);
3863 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
3864 timer = malloc(sizeof(*timer));
3866 timer_add(&timers, timer, when);
3867 timer_earliest(&timers, &when);
3868 free(timers_expire(&timers, when));
3869 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
3870 timer = malloc(sizeof(*timer));
3872 timer_add(&timers, timer, when);
3873 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3874 timer = malloc(sizeof(*timer));
3876 timer_add(&timers, timer, when);
3877 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
3878 timer = malloc(sizeof(*timer));
3880 timer_add(&timers, timer, when);
3881 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3882 timer = malloc(sizeof(*timer));
3884 timer_add(&timers, timer, when);
3885 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3886 timer = malloc(sizeof(*timer));
3888 timer_add(&timers, timer, when);
3889 timer_earliest(&timers, &when);
3890 free(timers_expire(&timers, when));
3891 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
3892 timer = malloc(sizeof(*timer));
3894 timer_add(&timers, timer, when);
3895 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3896 timer = malloc(sizeof(*timer));
3898 timer_add(&timers, timer, when);
3899 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3900 timer = malloc(sizeof(*timer));
3902 timer_add(&timers, timer, when);
3903 timer_earliest(&timers, &when);
3904 free(timers_expire(&timers, when));
3905 timer_earliest(&timers, &when);
3906 free(timers_expire(&timers, when));
3907 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3908 timer = malloc(sizeof(*timer));
3910 timer_add(&timers, timer, when);
3911 timer_earliest(&timers, &when);
3912 free(timers_expire(&timers, when));
3913 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3914 timer = malloc(sizeof(*timer));
3916 timer_add(&timers, timer, when);
3917 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
3918 timer = malloc(sizeof(*timer));
3920 timer_add(&timers, timer, when);
3921 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3922 timer = malloc(sizeof(*timer));
3924 timer_add(&timers, timer, when);
3925 timer_earliest(&timers, &when);
3926 free(timers_expire(&timers, when));
3927 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3928 timer = malloc(sizeof(*timer));
3930 timer_add(&timers, timer, when);
3931 timer_earliest(&timers, &when);
3932 free(timers_expire(&timers, when));
3933 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3934 timer = malloc(sizeof(*timer));
3936 timer_add(&timers, timer, when);
3937 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3938 timer = malloc(sizeof(*timer));
3940 timer_add(&timers, timer, when);
3941 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3942 timer = malloc(sizeof(*timer));
3944 timer_add(&timers, timer, when);
3945 timer_earliest(&timers, &when);
3946 free(timers_expire(&timers, when));
3947 timer_earliest(&timers, &when);
3948 free(timers_expire(&timers, when));
3949 timer_earliest(&timers, &when);
3950 free(timers_expire(&timers, when));
3951 timer_earliest(&timers, &when);
3952 free(timers_expire(&timers, when));
3953 timer_earliest(&timers, &when);
3954 free(timers_expire(&timers, when));
3955 timer_earliest(&timers, &when);
3956 free(timers_expire(&timers, when));
3957 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3958 timer = malloc(sizeof(*timer));
3960 timer_add(&timers, timer, when);
3961 timer_earliest(&timers, &when);
3962 free(timers_expire(&timers, when));
3963 timer_earliest(&timers, &when);
3964 free(timers_expire(&timers, when));
3965 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3966 timer = malloc(sizeof(*timer));
3968 timer_add(&timers, timer, when);
3969 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3970 timer = malloc(sizeof(*timer));
3972 timer_add(&timers, timer, when);
3973 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
3974 timer = malloc(sizeof(*timer));
3976 timer_add(&timers, timer, when);
3977 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
3978 timer = malloc(sizeof(*timer));
3980 timer_add(&timers, timer, when);
3981 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
3982 timer = malloc(sizeof(*timer));
3984 timer_add(&timers, timer, when);
3985 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
3986 timer = malloc(sizeof(*timer));
3988 timer_add(&timers, timer, when);
3989 timer_earliest(&timers, &when);
3990 free(timers_expire(&timers, when));
3991 timer_earliest(&timers, &when);
3992 free(timers_expire(&timers, when));
3993 timer_earliest(&timers, &when);
3994 free(timers_expire(&timers, when));
3995 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3996 timer = malloc(sizeof(*timer));
3998 timer_add(&timers, timer, when);
3999 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
4000 timer = malloc(sizeof(*timer));
4002 timer_add(&timers, timer, when);
4003 when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
4004 timer = malloc(sizeof(*timer));
4006 timer_add(&timers, timer, when);
4007 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4008 timer = malloc(sizeof(*timer));
4010 timer_add(&timers, timer, when);
4011 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4012 timer = malloc(sizeof(*timer));
4014 timer_add(&timers, timer, when);
4015 timer_earliest(&timers, &when);
4016 free(timers_expire(&timers, when));
4017 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
4018 timer = malloc(sizeof(*timer));
4020 timer_add(&timers, timer, when);
4021 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4022 timer = malloc(sizeof(*timer));
4024 timer_add(&timers, timer, when);
4025 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4026 timer = malloc(sizeof(*timer));
4028 timer_add(&timers, timer, when);
4029 timer_earliest(&timers, &when);
4030 free(timers_expire(&timers, when));
4031 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4032 timer = malloc(sizeof(*timer));
4034 timer_add(&timers, timer, when);
4035 timer_earliest(&timers, &when);
4036 free(timers_expire(&timers, when));
4037 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
4038 timer = malloc(sizeof(*timer));
4040 timer_add(&timers, timer, when);
4041 timer_earliest(&timers, &when);
4042 free(timers_expire(&timers, when));
4043 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4044 timer = malloc(sizeof(*timer));
4046 timer_add(&timers, timer, when);
4047 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4048 timer = malloc(sizeof(*timer));
4050 timer_add(&timers, timer, when);
4051 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
4052 timer = malloc(sizeof(*timer));
4054 timer_add(&timers, timer, when);
4055 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4056 timer = malloc(sizeof(*timer));
4058 timer_add(&timers, timer, when);
4059 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
4060 timer = malloc(sizeof(*timer));
4062 timer_add(&timers, timer, when);
4063 timer_earliest(&timers, &when);
4064 free(timers_expire(&timers, when));
4065 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4066 timer = malloc(sizeof(*timer));
4068 timer_add(&timers, timer, when);
4069 when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
4070 timer = malloc(sizeof(*timer));
4072 timer_add(&timers, timer, when);
4073 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4074 timer = malloc(sizeof(*timer));
4076 timer_add(&timers, timer, when);
4077 timer_earliest(&timers, &when);
4078 free(timers_expire(&timers, when));
4079 timer_earliest(&timers, &when);
4080 free(timers_expire(&timers, when));
4081 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
4082 timer = malloc(sizeof(*timer));
4084 timer_add(&timers, timer, when);
4085 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4086 timer = malloc(sizeof(*timer));
4088 timer_add(&timers, timer, when);
4089 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
4090 timer = malloc(sizeof(*timer));
4092 timer_add(&timers, timer, when);
4093 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4094 timer = malloc(sizeof(*timer));
4096 timer_add(&timers, timer, when);
4097 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
4098 timer = malloc(sizeof(*timer));
4100 timer_add(&timers, timer, when);
4101 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
4102 timer = malloc(sizeof(*timer));
4104 timer_add(&timers, timer, when);
4105 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
4106 timer = malloc(sizeof(*timer));
4108 timer_add(&timers, timer, when);
4109 timer_earliest(&timers, &when);
4110 free(timers_expire(&timers, when));
4111 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
4112 timer = malloc(sizeof(*timer));
4114 timer_add(&timers, timer, when);
4115 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
4116 timer = malloc(sizeof(*timer));
4118 timer_add(&timers, timer, when);
4119 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
4120 timer = malloc(sizeof(*timer));
4122 timer_add(&timers, timer, when);
4123 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4124 timer = malloc(sizeof(*timer));
4126 timer_add(&timers, timer, when);
4127 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
4128 timer = malloc(sizeof(*timer));
4130 timer_add(&timers, timer, when);
4131 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4132 timer = malloc(sizeof(*timer));
4134 timer_add(&timers, timer, when);
4135 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
4136 timer = malloc(sizeof(*timer));
4138 timer_add(&timers, timer, when);
4139 timer_earliest(&timers, &when);
4140 free(timers_expire(&timers, when));
4141 timer_earliest(&timers, &when);
4142 free(timers_expire(&timers, when));
4143 timer_earliest(&timers, &when);
4144 free(timers_expire(&timers, when));
4145 timer_earliest(&timers, &when);
4146 free(timers_expire(&timers, when));
4147 timer_earliest(&timers, &when);
4148 free(timers_expire(&timers, when));
4149 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
4150 timer = malloc(sizeof(*timer));
4152 timer_add(&timers, timer, when);
4153 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
4154 timer = malloc(sizeof(*timer));
4156 timer_add(&timers, timer, when);
4157 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4158 timer = malloc(sizeof(*timer));
4160 timer_add(&timers, timer, when);
4161 timer_earliest(&timers, &when);
4162 free(timers_expire(&timers, when));
4163 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
4164 timer = malloc(sizeof(*timer));
4166 timer_add(&timers, timer, when);
4167 timer_earliest(&timers, &when);
4168 free(timers_expire(&timers, when));
4169 timer_earliest(&timers, &when);
4170 free(timers_expire(&timers, when));
4171 timer_earliest(&timers, &when);
4172 free(timers_expire(&timers, when));
4173 timer_earliest(&timers, &when);
4174 free(timers_expire(&timers, when));
4175 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
4176 timer = malloc(sizeof(*timer));
4178 timer_add(&timers, timer, when);
4179 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
4180 timer = malloc(sizeof(*timer));
4182 timer_add(&timers, timer, when);
4183 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
4184 timer = malloc(sizeof(*timer));
4186 timer_add(&timers, timer, when);
4187 timer_earliest(&timers, &when);
4188 free(timers_expire(&timers, when));
4189 timer_earliest(&timers, &when);
4190 free(timers_expire(&timers, when));
4191 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
4192 timer = malloc(sizeof(*timer));
4194 timer_add(&timers, timer, when);
4195 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
4196 timer = malloc(sizeof(*timer));
4198 timer_add(&timers, timer, when);
4199 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4200 timer = malloc(sizeof(*timer));
4202 timer_add(&timers, timer, when);
4203 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4204 timer = malloc(sizeof(*timer));
4206 timer_add(&timers, timer, when);
4207 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
4208 timer = malloc(sizeof(*timer));
4210 timer_add(&timers, timer, when);
4211 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
4212 timer = malloc(sizeof(*timer));
4214 timer_add(&timers, timer, when);
4215 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
4216 timer = malloc(sizeof(*timer));
4218 timer_add(&timers, timer, when);
4219 timer_earliest(&timers, &when);
4220 free(timers_expire(&timers, when));
4221 timer_earliest(&timers, &when);
4222 free(timers_expire(&timers, when));
4223 timer_earliest(&timers, &when);
4224 free(timers_expire(&timers, when));
4225 timer_earliest(&timers, &when);
4226 free(timers_expire(&timers, when));
4227 timer_earliest(&timers, &when);
4228 free(timers_expire(&timers, when));
4229 timer_earliest(&timers, &when);
4230 free(timers_expire(&timers, when));
4231 when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
4232 timer = malloc(sizeof(*timer));
4234 timer_add(&timers, timer, when);
4235 timer_earliest(&timers, &when);
4236 free(timers_expire(&timers, when));
4237 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4238 timer = malloc(sizeof(*timer));
4240 timer_add(&timers, timer, when);
4241 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
4242 timer = malloc(sizeof(*timer));
4244 timer_add(&timers, timer, when);
4245 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4246 timer = malloc(sizeof(*timer));
4248 timer_add(&timers, timer, when);
4249 ok1(timers_check(&timers, NULL));
4250 timer_earliest(&timers, &when);
4251 free(timers_expire(&timers, when));
4252 timer_earliest(&timers, &when);
4253 free(timers_expire(&timers, when));
4254 timer_earliest(&timers, &when);
4255 free(timers_expire(&timers, when));
4256 timer_earliest(&timers, &when);
4257 free(timers_expire(&timers, when));
4258 timer_earliest(&timers, &when);
4259 free(timers_expire(&timers, when));
4260 timer_earliest(&timers, &when);
4261 free(timers_expire(&timers, when));
4262 timer_earliest(&timers, &when);
4263 free(timers_expire(&timers, when));
4264 timer_earliest(&timers, &when);
4265 free(timers_expire(&timers, when));
4266 timer_earliest(&timers, &when);
4267 free(timers_expire(&timers, when));
4268 timer_earliest(&timers, &when);
4269 free(timers_expire(&timers, when));
4270 timer_earliest(&timers, &when);
4271 free(timers_expire(&timers, when));
4272 timer_earliest(&timers, &when);
4273 free(timers_expire(&timers, when));
4274 timer_earliest(&timers, &when);
4275 free(timers_expire(&timers, when));
4276 timer_earliest(&timers, &when);
4277 free(timers_expire(&timers, when));
4278 timer_earliest(&timers, &when);
4279 free(timers_expire(&timers, when));
4280 timer_earliest(&timers, &when);
4281 free(timers_expire(&timers, when));
4282 timer_earliest(&timers, &when);
4283 free(timers_expire(&timers, when));
4284 timer_earliest(&timers, &when);
4285 free(timers_expire(&timers, when));
4286 timer_earliest(&timers, &when);
4287 free(timers_expire(&timers, when));
4288 timer_earliest(&timers, &when);
4289 free(timers_expire(&timers, when));
4290 timer_earliest(&timers, &when);
4291 free(timers_expire(&timers, when));
4292 timer_earliest(&timers, &when);
4293 free(timers_expire(&timers, when));
4294 timer_earliest(&timers, &when);
4295 free(timers_expire(&timers, when));
4296 timer_earliest(&timers, &when);
4297 free(timers_expire(&timers, when));
4298 timer_earliest(&timers, &when);
4299 free(timers_expire(&timers, when));
4300 timer_earliest(&timers, &when);
4301 free(timers_expire(&timers, when));
4302 timer_earliest(&timers, &when);
4303 free(timers_expire(&timers, when));
4304 timer_earliest(&timers, &when);
4305 free(timers_expire(&timers, when));
4306 timer_earliest(&timers, &when);
4307 free(timers_expire(&timers, when));
4308 timer_earliest(&timers, &when);
4309 free(timers_expire(&timers, when));
4310 timer_earliest(&timers, &when);
4311 free(timers_expire(&timers, when));
4312 timer_earliest(&timers, &when);
4313 free(timers_expire(&timers, when));
4314 timer_earliest(&timers, &when);
4315 free(timers_expire(&timers, when));
4316 timer_earliest(&timers, &when);
4317 free(timers_expire(&timers, when));
4318 timer_earliest(&timers, &when);
4319 free(timers_expire(&timers, when));
4320 timer_earliest(&timers, &when);
4321 free(timers_expire(&timers, when));
4322 timer_earliest(&timers, &when);
4323 free(timers_expire(&timers, when));
4325 while (timer_earliest(&timers, &when)) {
4326 free(timers_expire(&timers, when));
4328 ok1(timers_check(&timers, NULL));
4329 timers_cleanup(&timers);
4331 return exit_status();