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); timers_check(&timers, "add");
23 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
24 timer = malloc(sizeof(*timer));
26 timer_add(&timers, timer, when); timers_check(&timers, "add");
27 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
28 timer = malloc(sizeof(*timer));
30 timer_add(&timers, timer, when); timers_check(&timers, "add");
31 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
32 timer = malloc(sizeof(*timer));
34 timer_add(&timers, timer, when); timers_check(&timers, "add");
35 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
36 timer = malloc(sizeof(*timer));
38 timer_add(&timers, timer, when); timers_check(&timers, "add");
39 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
40 timer = malloc(sizeof(*timer));
42 timer_add(&timers, timer, when); timers_check(&timers, "add");
43 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
44 timer = malloc(sizeof(*timer));
46 timer_add(&timers, timer, when); timers_check(&timers, "add");
47 when.ts.tv_sec = 0; when.ts.tv_nsec = 18000000;
48 timer = malloc(sizeof(*timer));
50 timer_add(&timers, timer, when); timers_check(&timers, "add");
51 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
52 timer = malloc(sizeof(*timer));
54 timer_add(&timers, timer, when); timers_check(&timers, "add");
55 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
56 timer = malloc(sizeof(*timer));
58 timer_add(&timers, timer, when); timers_check(&timers, "add");
59 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
60 timer = malloc(sizeof(*timer));
62 timer_add(&timers, timer, when); timers_check(&timers, "add");
63 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
64 timer = malloc(sizeof(*timer));
66 timer_add(&timers, timer, when); timers_check(&timers, "add");
67 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
68 timer = malloc(sizeof(*timer));
70 timer_add(&timers, timer, when); timers_check(&timers, "add");
71 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
72 timer = malloc(sizeof(*timer));
74 timer_add(&timers, timer, when); timers_check(&timers, "add");
75 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
76 timer = malloc(sizeof(*timer));
78 timer_add(&timers, timer, when); timers_check(&timers, "add");
79 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
80 timer = malloc(sizeof(*timer));
82 timer_add(&timers, timer, when); timers_check(&timers, "add");
83 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
84 timer = malloc(sizeof(*timer));
86 timer_add(&timers, timer, when); timers_check(&timers, "add");
87 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
88 timer = malloc(sizeof(*timer));
90 timer_add(&timers, timer, when); timers_check(&timers, "add");
91 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
92 timer = malloc(sizeof(*timer));
94 timer_add(&timers, timer, when); timers_check(&timers, "add");
95 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
96 timer = malloc(sizeof(*timer));
98 timer_add(&timers, timer, when); timers_check(&timers, "add");
99 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
100 timer = malloc(sizeof(*timer));
102 timer_add(&timers, timer, when); timers_check(&timers, "add");
103 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
104 timer = malloc(sizeof(*timer));
106 timer_add(&timers, timer, when); timers_check(&timers, "add");
107 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
108 timer = malloc(sizeof(*timer));
110 timer_add(&timers, timer, when); timers_check(&timers, "add");
111 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
112 timer = malloc(sizeof(*timer));
114 timer_add(&timers, timer, when); timers_check(&timers, "add");
115 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
116 timer = malloc(sizeof(*timer));
118 timer_add(&timers, timer, when); timers_check(&timers, "add");
119 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
120 timer = malloc(sizeof(*timer));
122 timer_add(&timers, timer, when); timers_check(&timers, "add");
123 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
124 timer = malloc(sizeof(*timer));
126 timer_add(&timers, timer, when); timers_check(&timers, "add");
127 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
128 timer = malloc(sizeof(*timer));
130 timer_add(&timers, timer, when); timers_check(&timers, "add");
131 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
132 timer = malloc(sizeof(*timer));
134 timer_add(&timers, timer, when); timers_check(&timers, "add");
135 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
136 timer = malloc(sizeof(*timer));
138 timer_add(&timers, timer, when); timers_check(&timers, "add");
139 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
140 timer = malloc(sizeof(*timer));
142 timer_add(&timers, timer, when); timers_check(&timers, "add");
143 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
144 timer = malloc(sizeof(*timer));
146 timer_add(&timers, timer, when); timers_check(&timers, "add");
147 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
148 timer = malloc(sizeof(*timer));
150 timer_add(&timers, timer, when); timers_check(&timers, "add");
151 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
152 timer = malloc(sizeof(*timer));
154 timer_add(&timers, timer, when); timers_check(&timers, "add");
155 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
156 timer = malloc(sizeof(*timer));
158 timer_add(&timers, timer, when); timers_check(&timers, "add");
159 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
160 timer = malloc(sizeof(*timer));
162 timer_add(&timers, timer, when); timers_check(&timers, "add");
163 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
164 timer = malloc(sizeof(*timer));
166 timer_add(&timers, timer, when); timers_check(&timers, "add");
167 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
168 timer = malloc(sizeof(*timer));
170 timer_add(&timers, timer, when); timers_check(&timers, "add");
171 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
172 timer = malloc(sizeof(*timer));
174 timer_add(&timers, timer, when); timers_check(&timers, "add");
175 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
176 timer = malloc(sizeof(*timer));
178 timer_add(&timers, timer, when); timers_check(&timers, "add");
179 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
180 timer = malloc(sizeof(*timer));
182 timer_add(&timers, timer, when); timers_check(&timers, "add");
183 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
184 timer = malloc(sizeof(*timer));
186 timer_add(&timers, timer, when); timers_check(&timers, "add");
187 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
188 timer = malloc(sizeof(*timer));
190 timer_add(&timers, timer, when); timers_check(&timers, "add");
191 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
192 timer = malloc(sizeof(*timer));
194 timer_add(&timers, timer, when); timers_check(&timers, "add");
195 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
196 timer = malloc(sizeof(*timer));
198 timer_add(&timers, timer, when); timers_check(&timers, "add");
199 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
200 timer = malloc(sizeof(*timer));
202 timer_add(&timers, timer, when); timers_check(&timers, "add");
203 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
204 timer = malloc(sizeof(*timer));
206 timer_add(&timers, timer, when); timers_check(&timers, "add");
207 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
208 timer = malloc(sizeof(*timer));
210 timer_add(&timers, timer, when); timers_check(&timers, "add");
211 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
212 timer = malloc(sizeof(*timer));
214 timer_add(&timers, timer, when); timers_check(&timers, "add");
215 when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
216 timer = malloc(sizeof(*timer));
218 timer_add(&timers, timer, when); timers_check(&timers, "add");
219 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
220 timer = malloc(sizeof(*timer));
222 timer_add(&timers, timer, when); timers_check(&timers, "add");
223 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
224 timer = malloc(sizeof(*timer));
226 timer_add(&timers, timer, when); timers_check(&timers, "add");
227 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
228 timer = malloc(sizeof(*timer));
230 timer_add(&timers, timer, when); timers_check(&timers, "add");
231 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
232 timer = malloc(sizeof(*timer));
234 timer_add(&timers, timer, when); timers_check(&timers, "add");
235 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
236 timer = malloc(sizeof(*timer));
238 timer_add(&timers, timer, when); timers_check(&timers, "add");
239 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
240 timer = malloc(sizeof(*timer));
242 timer_add(&timers, timer, when); timers_check(&timers, "add");
243 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
244 timer = malloc(sizeof(*timer));
246 timer_add(&timers, timer, when); timers_check(&timers, "add");
247 when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
248 timer = malloc(sizeof(*timer));
250 timer_add(&timers, timer, when); timers_check(&timers, "add");
251 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
252 timer = malloc(sizeof(*timer));
254 timer_add(&timers, timer, when); timers_check(&timers, "add");
255 when.ts.tv_sec = 0; when.ts.tv_nsec = 13000000;
256 timer = malloc(sizeof(*timer));
258 timer_add(&timers, timer, when); timers_check(&timers, "add");
259 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
260 timer = malloc(sizeof(*timer));
262 timer_add(&timers, timer, when); timers_check(&timers, "add");
263 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
264 timer = malloc(sizeof(*timer));
266 timer_add(&timers, timer, when); timers_check(&timers, "add");
267 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
268 timer = malloc(sizeof(*timer));
270 timer_add(&timers, timer, when); timers_check(&timers, "add");
271 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
272 timer = malloc(sizeof(*timer));
274 timer_add(&timers, timer, when); timers_check(&timers, "add");
275 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
276 timer = malloc(sizeof(*timer));
278 timer_add(&timers, timer, when); timers_check(&timers, "add");
279 when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
280 timer = malloc(sizeof(*timer));
282 timer_add(&timers, timer, when); timers_check(&timers, "add");
283 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
284 timer = malloc(sizeof(*timer));
286 timer_add(&timers, timer, when); timers_check(&timers, "add");
287 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
288 timer = malloc(sizeof(*timer));
290 timer_add(&timers, timer, when); timers_check(&timers, "add");
291 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
292 timer = malloc(sizeof(*timer));
294 timer_add(&timers, timer, when); timers_check(&timers, "add");
295 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
296 timer = malloc(sizeof(*timer));
298 timer_add(&timers, timer, when); timers_check(&timers, "add");
299 when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
300 timer = malloc(sizeof(*timer));
302 timer_add(&timers, timer, when); timers_check(&timers, "add");
303 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
304 timer = malloc(sizeof(*timer));
306 timer_add(&timers, timer, when); timers_check(&timers, "add");
307 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
308 timer = malloc(sizeof(*timer));
310 timer_add(&timers, timer, when); timers_check(&timers, "add");
311 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
312 timer = malloc(sizeof(*timer));
314 timer_add(&timers, timer, when); timers_check(&timers, "add");
315 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
316 timer = malloc(sizeof(*timer));
318 timer_add(&timers, timer, when); timers_check(&timers, "add");
319 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
320 timer = malloc(sizeof(*timer));
322 timer_add(&timers, timer, when); timers_check(&timers, "add");
323 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
324 timer = malloc(sizeof(*timer));
326 timer_add(&timers, timer, when); timers_check(&timers, "add");
327 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
328 timer = malloc(sizeof(*timer));
330 timer_add(&timers, timer, when); timers_check(&timers, "add");
331 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
332 timer = malloc(sizeof(*timer));
334 timer_add(&timers, timer, when); timers_check(&timers, "add");
335 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
336 timer = malloc(sizeof(*timer));
338 timer_add(&timers, timer, when); timers_check(&timers, "add");
339 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
340 timer = malloc(sizeof(*timer));
342 timer_add(&timers, timer, when); timers_check(&timers, "add");
343 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
344 timer = malloc(sizeof(*timer));
346 timer_add(&timers, timer, when); timers_check(&timers, "add");
347 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
348 timer = malloc(sizeof(*timer));
350 timer_add(&timers, timer, when); timers_check(&timers, "add");
351 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
352 timer = malloc(sizeof(*timer));
354 timer_add(&timers, timer, when); timers_check(&timers, "add");
355 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
356 timer = malloc(sizeof(*timer));
358 timer_add(&timers, timer, when); timers_check(&timers, "add");
359 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
360 timer = malloc(sizeof(*timer));
362 timer_add(&timers, timer, when); timers_check(&timers, "add");
363 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
364 timer = malloc(sizeof(*timer));
366 timer_add(&timers, timer, when); timers_check(&timers, "add");
367 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
368 timer = malloc(sizeof(*timer));
370 timer_add(&timers, timer, when); timers_check(&timers, "add");
371 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
372 timer = malloc(sizeof(*timer));
374 timer_add(&timers, timer, when); timers_check(&timers, "add");
375 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
376 timer = malloc(sizeof(*timer));
378 timer_add(&timers, timer, when); timers_check(&timers, "add");
379 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
380 timer = malloc(sizeof(*timer));
382 timer_add(&timers, timer, when); timers_check(&timers, "add");
383 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
384 timer = malloc(sizeof(*timer));
386 timer_add(&timers, timer, when); timers_check(&timers, "add");
387 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
388 timer = malloc(sizeof(*timer));
390 timer_add(&timers, timer, when); timers_check(&timers, "add");
391 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
392 timer = malloc(sizeof(*timer));
394 timer_add(&timers, timer, when); timers_check(&timers, "add");
395 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
396 timer = malloc(sizeof(*timer));
398 timer_add(&timers, timer, when); timers_check(&timers, "add");
399 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
400 timer = malloc(sizeof(*timer));
402 timer_add(&timers, timer, when); timers_check(&timers, "add");
403 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
404 timer = malloc(sizeof(*timer));
406 timer_add(&timers, timer, when); timers_check(&timers, "add");
407 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
408 timer = malloc(sizeof(*timer));
410 timer_add(&timers, timer, when); timers_check(&timers, "add");
411 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
412 timer = malloc(sizeof(*timer));
414 timer_add(&timers, timer, when); timers_check(&timers, "add");
415 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
416 timer = malloc(sizeof(*timer));
418 timer_add(&timers, timer, when); timers_check(&timers, "add");
419 when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
420 timer = malloc(sizeof(*timer));
422 timer_add(&timers, timer, when); timers_check(&timers, "add");
423 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
424 timer = malloc(sizeof(*timer));
426 timer_add(&timers, timer, when); timers_check(&timers, "add");
427 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
428 timer = malloc(sizeof(*timer));
430 timer_add(&timers, timer, when); timers_check(&timers, "add");
431 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
432 timer = malloc(sizeof(*timer));
434 timer_add(&timers, timer, when); timers_check(&timers, "add");
435 when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000;
436 timer = malloc(sizeof(*timer));
438 timer_add(&timers, timer, when); timers_check(&timers, "add");
439 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
440 timer = malloc(sizeof(*timer));
442 timer_add(&timers, timer, when); timers_check(&timers, "add");
443 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
444 timer = malloc(sizeof(*timer));
446 timer_add(&timers, timer, when); timers_check(&timers, "add");
447 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
448 timer = malloc(sizeof(*timer));
450 timer_add(&timers, timer, when); timers_check(&timers, "add");
451 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
452 timer = malloc(sizeof(*timer));
454 timer_add(&timers, timer, when); timers_check(&timers, "add");
455 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
456 timer = malloc(sizeof(*timer));
458 timer_add(&timers, timer, when); timers_check(&timers, "add");
459 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
460 timer = malloc(sizeof(*timer));
462 timer_add(&timers, timer, when); timers_check(&timers, "add");
463 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
464 timer = malloc(sizeof(*timer));
466 timer_add(&timers, timer, when); timers_check(&timers, "add");
467 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
468 timer = malloc(sizeof(*timer));
470 timer_add(&timers, timer, when); timers_check(&timers, "add");
471 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
472 timer = malloc(sizeof(*timer));
474 timer_add(&timers, timer, when); timers_check(&timers, "add");
475 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
476 timer = malloc(sizeof(*timer));
478 timer_add(&timers, timer, when); timers_check(&timers, "add");
479 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
480 timer = malloc(sizeof(*timer));
482 timer_add(&timers, timer, when); timers_check(&timers, "add");
483 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
484 timer = malloc(sizeof(*timer));
486 timer_add(&timers, timer, when); timers_check(&timers, "add");
487 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
488 timer = malloc(sizeof(*timer));
490 timer_add(&timers, timer, when); timers_check(&timers, "add");
491 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
492 timer = malloc(sizeof(*timer));
494 timer_add(&timers, timer, when); timers_check(&timers, "add");
495 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
496 timer = malloc(sizeof(*timer));
498 timer_add(&timers, timer, when); timers_check(&timers, "add");
499 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
500 timer = malloc(sizeof(*timer));
502 timer_add(&timers, timer, when); timers_check(&timers, "add");
503 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
504 timer = malloc(sizeof(*timer));
506 timer_add(&timers, timer, when); timers_check(&timers, "add");
507 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
508 timer = malloc(sizeof(*timer));
510 timer_add(&timers, timer, when); timers_check(&timers, "add");
511 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
512 timer = malloc(sizeof(*timer));
514 timer_add(&timers, timer, when); timers_check(&timers, "add");
515 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
516 timer = malloc(sizeof(*timer));
518 timer_add(&timers, timer, when); timers_check(&timers, "add");
519 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
520 timer = malloc(sizeof(*timer));
522 timer_add(&timers, timer, when); timers_check(&timers, "add");
523 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
524 timer = malloc(sizeof(*timer));
526 timer_add(&timers, timer, when); timers_check(&timers, "add");
527 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
528 timer = malloc(sizeof(*timer));
530 timer_add(&timers, timer, when); timers_check(&timers, "add");
531 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
532 timer = malloc(sizeof(*timer));
534 timer_add(&timers, timer, when); timers_check(&timers, "add");
535 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
536 timer = malloc(sizeof(*timer));
538 timer_add(&timers, timer, when); timers_check(&timers, "add");
539 when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
540 timer = malloc(sizeof(*timer));
542 timer_add(&timers, timer, when); timers_check(&timers, "add");
543 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
544 timer = malloc(sizeof(*timer));
546 timer_add(&timers, timer, when); timers_check(&timers, "add");
547 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
548 timer = malloc(sizeof(*timer));
550 timer_add(&timers, timer, when); timers_check(&timers, "add");
551 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
552 timer = malloc(sizeof(*timer));
554 timer_add(&timers, timer, when); timers_check(&timers, "add");
555 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
556 timer = malloc(sizeof(*timer));
558 timer_add(&timers, timer, when); timers_check(&timers, "add");
559 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
560 timer = malloc(sizeof(*timer));
562 timer_add(&timers, timer, when); timers_check(&timers, "add");
563 when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
564 timer = malloc(sizeof(*timer));
566 timer_add(&timers, timer, when); timers_check(&timers, "add");
567 when.ts.tv_sec = 0; when.ts.tv_nsec = 90000000;
568 timer = malloc(sizeof(*timer));
570 timer_add(&timers, timer, when); timers_check(&timers, "add");
571 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
572 timer = malloc(sizeof(*timer));
574 timer_add(&timers, timer, when); timers_check(&timers, "add");
575 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
576 timer = malloc(sizeof(*timer));
578 timer_add(&timers, timer, when); timers_check(&timers, "add");
579 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
580 timer = malloc(sizeof(*timer));
582 timer_add(&timers, timer, when); timers_check(&timers, "add");
583 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
584 timer = malloc(sizeof(*timer));
586 timer_add(&timers, timer, when); timers_check(&timers, "add");
587 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
588 timer = malloc(sizeof(*timer));
590 timer_add(&timers, timer, when); timers_check(&timers, "add");
591 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
592 timer = malloc(sizeof(*timer));
594 timer_add(&timers, timer, when); timers_check(&timers, "add");
595 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
596 timer = malloc(sizeof(*timer));
598 timer_add(&timers, timer, when); timers_check(&timers, "add");
599 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
600 timer = malloc(sizeof(*timer));
602 timer_add(&timers, timer, when); timers_check(&timers, "add");
603 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
604 timer = malloc(sizeof(*timer));
606 timer_add(&timers, timer, when); timers_check(&timers, "add");
607 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
608 timer = malloc(sizeof(*timer));
610 timer_add(&timers, timer, when); timers_check(&timers, "add");
611 when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
612 timer = malloc(sizeof(*timer));
614 timer_add(&timers, timer, when); timers_check(&timers, "add");
615 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
616 timer = malloc(sizeof(*timer));
618 timer_add(&timers, timer, when); timers_check(&timers, "add");
619 when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000;
620 timer = malloc(sizeof(*timer));
622 timer_add(&timers, timer, when); timers_check(&timers, "add");
623 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
624 timer = malloc(sizeof(*timer));
626 timer_add(&timers, timer, when); timers_check(&timers, "add");
627 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
628 timer = malloc(sizeof(*timer));
630 timer_add(&timers, timer, when); timers_check(&timers, "add");
631 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
632 timer = malloc(sizeof(*timer));
634 timer_add(&timers, timer, when); timers_check(&timers, "add");
635 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
636 timer = malloc(sizeof(*timer));
638 timer_add(&timers, timer, when); timers_check(&timers, "add");
639 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
640 timer = malloc(sizeof(*timer));
642 timer_add(&timers, timer, when); timers_check(&timers, "add");
643 when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
644 timer = malloc(sizeof(*timer));
646 timer_add(&timers, timer, when); timers_check(&timers, "add");
647 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
648 timer = malloc(sizeof(*timer));
650 timer_add(&timers, timer, when); timers_check(&timers, "add");
651 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
652 timer = malloc(sizeof(*timer));
654 timer_add(&timers, timer, when); timers_check(&timers, "add");
655 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
656 timer = malloc(sizeof(*timer));
658 timer_add(&timers, timer, when); timers_check(&timers, "add");
659 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
660 timer = malloc(sizeof(*timer));
662 timer_add(&timers, timer, when); timers_check(&timers, "add");
663 when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
664 timer = malloc(sizeof(*timer));
666 timer_add(&timers, timer, when); timers_check(&timers, "add");
667 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
668 timer = malloc(sizeof(*timer));
670 timer_add(&timers, timer, when); timers_check(&timers, "add");
671 when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
672 timer = malloc(sizeof(*timer));
674 timer_add(&timers, timer, when); timers_check(&timers, "add");
675 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
676 timer = malloc(sizeof(*timer));
678 timer_add(&timers, timer, when); timers_check(&timers, "add");
679 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
680 timer = malloc(sizeof(*timer));
682 timer_add(&timers, timer, when); timers_check(&timers, "add");
683 when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
684 timer = malloc(sizeof(*timer));
686 timer_add(&timers, timer, when); timers_check(&timers, "add");
687 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
688 timer = malloc(sizeof(*timer));
690 timer_add(&timers, timer, when); timers_check(&timers, "add");
691 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
692 timer = malloc(sizeof(*timer));
694 timer_add(&timers, timer, when); timers_check(&timers, "add");
695 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
696 timer = malloc(sizeof(*timer));
698 timer_add(&timers, timer, when); timers_check(&timers, "add");
699 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
700 timer = malloc(sizeof(*timer));
702 timer_add(&timers, timer, when); timers_check(&timers, "add");
703 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
704 timer = malloc(sizeof(*timer));
706 timer_add(&timers, timer, when); timers_check(&timers, "add");
707 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
708 timer = malloc(sizeof(*timer));
710 timer_add(&timers, timer, when); timers_check(&timers, "add");
711 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
712 timer = malloc(sizeof(*timer));
714 timer_add(&timers, timer, when); timers_check(&timers, "add");
715 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
716 timer = malloc(sizeof(*timer));
718 timer_add(&timers, timer, when); timers_check(&timers, "add");
719 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
720 timer = malloc(sizeof(*timer));
722 timer_add(&timers, timer, when); timers_check(&timers, "add");
723 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
724 timer = malloc(sizeof(*timer));
726 timer_add(&timers, timer, when); timers_check(&timers, "add");
727 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
728 timer = malloc(sizeof(*timer));
730 timer_add(&timers, timer, when); timers_check(&timers, "add");
731 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
732 timer = malloc(sizeof(*timer));
734 timer_add(&timers, timer, when); timers_check(&timers, "add");
735 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
736 timer = malloc(sizeof(*timer));
738 timer_add(&timers, timer, when); timers_check(&timers, "add");
739 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
740 timer = malloc(sizeof(*timer));
742 timer_add(&timers, timer, when); timers_check(&timers, "add");
743 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
744 timer = malloc(sizeof(*timer));
746 timer_add(&timers, timer, when); timers_check(&timers, "add");
747 when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
748 timer = malloc(sizeof(*timer));
750 timer_add(&timers, timer, when); timers_check(&timers, "add");
751 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
752 timer = malloc(sizeof(*timer));
754 timer_add(&timers, timer, when); timers_check(&timers, "add");
755 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
756 timer = malloc(sizeof(*timer));
758 timer_add(&timers, timer, when); timers_check(&timers, "add");
759 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
760 timer = malloc(sizeof(*timer));
762 timer_add(&timers, timer, when); timers_check(&timers, "add");
763 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
764 timer = malloc(sizeof(*timer));
766 timer_add(&timers, timer, when); timers_check(&timers, "add");
767 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
768 timer = malloc(sizeof(*timer));
770 timer_add(&timers, timer, when); timers_check(&timers, "add");
771 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
772 timer = malloc(sizeof(*timer));
774 timer_add(&timers, timer, when); timers_check(&timers, "add");
775 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
776 timer = malloc(sizeof(*timer));
778 timer_add(&timers, timer, when); timers_check(&timers, "add");
779 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
780 timer = malloc(sizeof(*timer));
782 timer_add(&timers, timer, when); timers_check(&timers, "add");
783 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
784 timer = malloc(sizeof(*timer));
786 timer_add(&timers, timer, when); timers_check(&timers, "add");
787 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
788 timer = malloc(sizeof(*timer));
790 timer_add(&timers, timer, when); timers_check(&timers, "add");
791 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
792 timer = malloc(sizeof(*timer));
794 timer_add(&timers, timer, when); timers_check(&timers, "add");
795 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
796 timer = malloc(sizeof(*timer));
798 timer_add(&timers, timer, when); timers_check(&timers, "add");
799 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
800 timer = malloc(sizeof(*timer));
802 timer_add(&timers, timer, when); timers_check(&timers, "add");
803 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
804 timer = malloc(sizeof(*timer));
806 timer_add(&timers, timer, when); timers_check(&timers, "add");
807 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
808 timer = malloc(sizeof(*timer));
810 timer_add(&timers, timer, when); timers_check(&timers, "add");
811 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
812 timer = malloc(sizeof(*timer));
814 timer_add(&timers, timer, when); timers_check(&timers, "add");
815 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
816 timer = malloc(sizeof(*timer));
818 timer_add(&timers, timer, when); timers_check(&timers, "add");
819 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
820 timer = malloc(sizeof(*timer));
822 timer_add(&timers, timer, when); timers_check(&timers, "add");
823 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
824 timer = malloc(sizeof(*timer));
826 timer_add(&timers, timer, when); timers_check(&timers, "add");
827 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
828 timer = malloc(sizeof(*timer));
830 timer_add(&timers, timer, when); timers_check(&timers, "add");
831 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
832 timer = malloc(sizeof(*timer));
834 timer_add(&timers, timer, when); timers_check(&timers, "add");
835 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
836 timer = malloc(sizeof(*timer));
838 timer_add(&timers, timer, when); timers_check(&timers, "add");
839 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
840 timer = malloc(sizeof(*timer));
842 timer_add(&timers, timer, when); timers_check(&timers, "add");
843 when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
844 timer = malloc(sizeof(*timer));
846 timer_add(&timers, timer, when); timers_check(&timers, "add");
847 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
848 timer = malloc(sizeof(*timer));
850 timer_add(&timers, timer, when); timers_check(&timers, "add");
851 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
852 timer = malloc(sizeof(*timer));
854 timer_add(&timers, timer, when); timers_check(&timers, "add");
855 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
856 timer = malloc(sizeof(*timer));
858 timer_add(&timers, timer, when); timers_check(&timers, "add");
859 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
860 timer = malloc(sizeof(*timer));
862 timer_add(&timers, timer, when); timers_check(&timers, "add");
863 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
864 timer = malloc(sizeof(*timer));
866 timer_add(&timers, timer, when); timers_check(&timers, "add");
867 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
868 timer = malloc(sizeof(*timer));
870 timer_add(&timers, timer, when); timers_check(&timers, "add");
871 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
872 timer = malloc(sizeof(*timer));
874 timer_add(&timers, timer, when); timers_check(&timers, "add");
875 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
876 timer = malloc(sizeof(*timer));
878 timer_add(&timers, timer, when); timers_check(&timers, "add");
879 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
880 timer = malloc(sizeof(*timer));
882 timer_add(&timers, timer, when); timers_check(&timers, "add");
883 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
884 timer = malloc(sizeof(*timer));
886 timer_add(&timers, timer, when); timers_check(&timers, "add");
887 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
888 timer = malloc(sizeof(*timer));
890 timer_add(&timers, timer, when); timers_check(&timers, "add");
891 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
892 timer = malloc(sizeof(*timer));
894 timer_add(&timers, timer, when); timers_check(&timers, "add");
895 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
896 timer = malloc(sizeof(*timer));
898 timer_add(&timers, timer, when); timers_check(&timers, "add");
899 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
900 timer = malloc(sizeof(*timer));
902 timer_add(&timers, timer, when); timers_check(&timers, "add");
903 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
904 timer = malloc(sizeof(*timer));
906 timer_add(&timers, timer, when); timers_check(&timers, "add");
907 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
908 timer = malloc(sizeof(*timer));
910 timer_add(&timers, timer, when); timers_check(&timers, "add");
911 when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
912 timer = malloc(sizeof(*timer));
914 timer_add(&timers, timer, when); timers_check(&timers, "add");
915 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
916 timer = malloc(sizeof(*timer));
918 timer_add(&timers, timer, when); timers_check(&timers, "add");
919 when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
920 timer = malloc(sizeof(*timer));
922 timer_add(&timers, timer, when); timers_check(&timers, "add");
923 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
924 timer = malloc(sizeof(*timer));
926 timer_add(&timers, timer, when); timers_check(&timers, "add");
927 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
928 timer = malloc(sizeof(*timer));
930 timer_add(&timers, timer, when); timers_check(&timers, "add");
931 when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000;
932 timer = malloc(sizeof(*timer));
934 timer_add(&timers, timer, when); timers_check(&timers, "add");
935 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
936 timer = malloc(sizeof(*timer));
938 timer_add(&timers, timer, when); timers_check(&timers, "add");
939 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
940 timer = malloc(sizeof(*timer));
942 timer_add(&timers, timer, when); timers_check(&timers, "add");
943 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
944 timer = malloc(sizeof(*timer));
946 timer_add(&timers, timer, when); timers_check(&timers, "add");
947 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
948 timer = malloc(sizeof(*timer));
950 timer_add(&timers, timer, when); timers_check(&timers, "add");
951 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
952 timer = malloc(sizeof(*timer));
954 timer_add(&timers, timer, when); timers_check(&timers, "add");
955 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
956 timer = malloc(sizeof(*timer));
958 timer_add(&timers, timer, when); timers_check(&timers, "add");
959 when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
960 timer = malloc(sizeof(*timer));
962 timer_add(&timers, timer, when); timers_check(&timers, "add");
963 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
964 timer = malloc(sizeof(*timer));
966 timer_add(&timers, timer, when); timers_check(&timers, "add");
967 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
968 timer = malloc(sizeof(*timer));
970 timer_add(&timers, timer, when); timers_check(&timers, "add");
971 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
972 timer = malloc(sizeof(*timer));
974 timer_add(&timers, timer, when); timers_check(&timers, "add");
975 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
976 timer = malloc(sizeof(*timer));
978 timer_add(&timers, timer, when); timers_check(&timers, "add");
979 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
980 timer = malloc(sizeof(*timer));
982 timer_add(&timers, timer, when); timers_check(&timers, "add");
983 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
984 timer = malloc(sizeof(*timer));
986 timer_add(&timers, timer, when); timers_check(&timers, "add");
987 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
988 timer = malloc(sizeof(*timer));
990 timer_add(&timers, timer, when); timers_check(&timers, "add");
991 when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
992 timer = malloc(sizeof(*timer));
994 timer_add(&timers, timer, when); timers_check(&timers, "add");
995 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
996 timer = malloc(sizeof(*timer));
998 timer_add(&timers, timer, when); timers_check(&timers, "add");
999 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1000 timer = malloc(sizeof(*timer));
1002 timer_add(&timers, timer, when); timers_check(&timers, "add");
1003 when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
1004 timer = malloc(sizeof(*timer));
1006 timer_add(&timers, timer, when); timers_check(&timers, "add");
1007 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1008 timer = malloc(sizeof(*timer));
1010 timer_add(&timers, timer, when); timers_check(&timers, "add");
1011 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
1012 timer = malloc(sizeof(*timer));
1014 timer_add(&timers, timer, when); timers_check(&timers, "add");
1015 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1016 timer = malloc(sizeof(*timer));
1018 timer_add(&timers, timer, when); timers_check(&timers, "add");
1019 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
1020 timer = malloc(sizeof(*timer));
1022 timer_add(&timers, timer, when); timers_check(&timers, "add");
1023 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
1024 timer = malloc(sizeof(*timer));
1026 timer_add(&timers, timer, when); timers_check(&timers, "add");
1027 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
1028 timer = malloc(sizeof(*timer));
1030 timer_add(&timers, timer, when); timers_check(&timers, "add");
1031 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1032 timer = malloc(sizeof(*timer));
1034 timer_add(&timers, timer, when); timers_check(&timers, "add");
1035 when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
1036 timer = malloc(sizeof(*timer));
1038 timer_add(&timers, timer, when); timers_check(&timers, "add");
1039 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
1040 timer = malloc(sizeof(*timer));
1042 timer_add(&timers, timer, when); timers_check(&timers, "add");
1043 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
1044 timer = malloc(sizeof(*timer));
1046 timer_add(&timers, timer, when); timers_check(&timers, "add");
1047 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
1048 timer = malloc(sizeof(*timer));
1050 timer_add(&timers, timer, when); timers_check(&timers, "add");
1051 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1052 timer = malloc(sizeof(*timer));
1054 timer_add(&timers, timer, when); timers_check(&timers, "add");
1055 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
1056 timer = malloc(sizeof(*timer));
1058 timer_add(&timers, timer, when); timers_check(&timers, "add");
1059 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
1060 timer = malloc(sizeof(*timer));
1062 timer_add(&timers, timer, when); timers_check(&timers, "add");
1063 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1064 timer = malloc(sizeof(*timer));
1066 timer_add(&timers, timer, when); timers_check(&timers, "add");
1067 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1068 timer = malloc(sizeof(*timer));
1070 timer_add(&timers, timer, when); timers_check(&timers, "add");
1071 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1072 timer = malloc(sizeof(*timer));
1074 timer_add(&timers, timer, when); timers_check(&timers, "add");
1075 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
1076 timer = malloc(sizeof(*timer));
1078 timer_add(&timers, timer, when); timers_check(&timers, "add");
1079 when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
1080 timer = malloc(sizeof(*timer));
1082 timer_add(&timers, timer, when); timers_check(&timers, "add");
1083 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1084 timer = malloc(sizeof(*timer));
1086 timer_add(&timers, timer, when); timers_check(&timers, "add");
1087 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1088 timer = malloc(sizeof(*timer));
1090 timer_add(&timers, timer, when); timers_check(&timers, "add");
1091 when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000;
1092 timer = malloc(sizeof(*timer));
1094 timer_add(&timers, timer, when); timers_check(&timers, "add");
1095 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
1096 timer = malloc(sizeof(*timer));
1098 timer_add(&timers, timer, when); timers_check(&timers, "add");
1099 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1100 timer = malloc(sizeof(*timer));
1102 timer_add(&timers, timer, when); timers_check(&timers, "add");
1103 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
1104 timer = malloc(sizeof(*timer));
1106 timer_add(&timers, timer, when); timers_check(&timers, "add");
1107 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1108 timer = malloc(sizeof(*timer));
1110 timer_add(&timers, timer, when); timers_check(&timers, "add");
1111 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1112 timer = malloc(sizeof(*timer));
1114 timer_add(&timers, timer, when); timers_check(&timers, "add");
1115 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
1116 timer = malloc(sizeof(*timer));
1118 timer_add(&timers, timer, when); timers_check(&timers, "add");
1119 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
1120 timer = malloc(sizeof(*timer));
1122 timer_add(&timers, timer, when); timers_check(&timers, "add");
1123 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
1124 timer = malloc(sizeof(*timer));
1126 timer_add(&timers, timer, when); timers_check(&timers, "add");
1127 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
1128 timer = malloc(sizeof(*timer));
1130 timer_add(&timers, timer, when); timers_check(&timers, "add");
1131 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
1132 timer = malloc(sizeof(*timer));
1134 timer_add(&timers, timer, when); timers_check(&timers, "add");
1135 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
1136 timer = malloc(sizeof(*timer));
1138 timer_add(&timers, timer, when); timers_check(&timers, "add");
1139 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1140 timer = malloc(sizeof(*timer));
1142 timer_add(&timers, timer, when); timers_check(&timers, "add");
1143 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
1144 timer = malloc(sizeof(*timer));
1146 timer_add(&timers, timer, when); timers_check(&timers, "add");
1147 when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
1148 timer = malloc(sizeof(*timer));
1150 timer_add(&timers, timer, when); timers_check(&timers, "add");
1151 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
1152 timer = malloc(sizeof(*timer));
1154 timer_add(&timers, timer, when); timers_check(&timers, "add");
1155 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
1156 timer = malloc(sizeof(*timer));
1158 timer_add(&timers, timer, when); timers_check(&timers, "add");
1159 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1160 timer = malloc(sizeof(*timer));
1162 timer_add(&timers, timer, when); timers_check(&timers, "add");
1163 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
1164 timer = malloc(sizeof(*timer));
1166 timer_add(&timers, timer, when); timers_check(&timers, "add");
1167 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
1168 timer = malloc(sizeof(*timer));
1170 timer_add(&timers, timer, when); timers_check(&timers, "add");
1171 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
1172 timer = malloc(sizeof(*timer));
1174 timer_add(&timers, timer, when); timers_check(&timers, "add");
1175 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
1176 timer = malloc(sizeof(*timer));
1178 timer_add(&timers, timer, when); timers_check(&timers, "add");
1179 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
1180 timer = malloc(sizeof(*timer));
1182 timer_add(&timers, timer, when); timers_check(&timers, "add");
1183 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
1184 timer = malloc(sizeof(*timer));
1186 timer_add(&timers, timer, when); timers_check(&timers, "add");
1187 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
1188 timer = malloc(sizeof(*timer));
1190 timer_add(&timers, timer, when); timers_check(&timers, "add");
1191 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
1192 timer = malloc(sizeof(*timer));
1194 timer_add(&timers, timer, when); timers_check(&timers, "add");
1195 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
1196 timer = malloc(sizeof(*timer));
1198 timer_add(&timers, timer, when); timers_check(&timers, "add");
1199 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1200 timer = malloc(sizeof(*timer));
1202 timer_add(&timers, timer, when); timers_check(&timers, "add");
1203 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1204 timer = malloc(sizeof(*timer));
1206 timer_add(&timers, timer, when); timers_check(&timers, "add");
1207 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
1208 timer = malloc(sizeof(*timer));
1210 timer_add(&timers, timer, when); timers_check(&timers, "add");
1211 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
1212 timer = malloc(sizeof(*timer));
1214 timer_add(&timers, timer, when); timers_check(&timers, "add");
1215 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1216 timer = malloc(sizeof(*timer));
1218 timer_add(&timers, timer, when); timers_check(&timers, "add");
1219 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
1220 timer = malloc(sizeof(*timer));
1222 timer_add(&timers, timer, when); timers_check(&timers, "add");
1223 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
1224 timer = malloc(sizeof(*timer));
1226 timer_add(&timers, timer, when); timers_check(&timers, "add");
1227 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
1228 timer = malloc(sizeof(*timer));
1230 timer_add(&timers, timer, when); timers_check(&timers, "add");
1231 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
1232 timer = malloc(sizeof(*timer));
1234 timer_add(&timers, timer, when); timers_check(&timers, "add");
1235 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
1236 timer = malloc(sizeof(*timer));
1238 timer_add(&timers, timer, when); timers_check(&timers, "add");
1239 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
1240 timer = malloc(sizeof(*timer));
1242 timer_add(&timers, timer, when); timers_check(&timers, "add");
1243 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
1244 timer = malloc(sizeof(*timer));
1246 timer_add(&timers, timer, when); timers_check(&timers, "add");
1247 when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
1248 timer = malloc(sizeof(*timer));
1250 timer_add(&timers, timer, when); timers_check(&timers, "add");
1251 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
1252 timer = malloc(sizeof(*timer));
1254 timer_add(&timers, timer, when); timers_check(&timers, "add");
1255 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1256 timer = malloc(sizeof(*timer));
1258 timer_add(&timers, timer, when); timers_check(&timers, "add");
1259 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
1260 timer = malloc(sizeof(*timer));
1262 timer_add(&timers, timer, when); timers_check(&timers, "add");
1263 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
1264 timer = malloc(sizeof(*timer));
1266 timer_add(&timers, timer, when); timers_check(&timers, "add");
1267 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1268 timer = malloc(sizeof(*timer));
1270 timer_add(&timers, timer, when); timers_check(&timers, "add");
1271 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
1272 timer = malloc(sizeof(*timer));
1274 timer_add(&timers, timer, when); timers_check(&timers, "add");
1275 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
1276 timer = malloc(sizeof(*timer));
1278 timer_add(&timers, timer, when); timers_check(&timers, "add");
1279 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1280 timer = malloc(sizeof(*timer));
1282 timer_add(&timers, timer, when); timers_check(&timers, "add");
1283 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
1284 timer = malloc(sizeof(*timer));
1286 timer_add(&timers, timer, when); timers_check(&timers, "add");
1287 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
1288 timer = malloc(sizeof(*timer));
1290 timer_add(&timers, timer, when); timers_check(&timers, "add");
1291 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
1292 timer = malloc(sizeof(*timer));
1294 timer_add(&timers, timer, when); timers_check(&timers, "add");
1295 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1296 timer = malloc(sizeof(*timer));
1298 timer_add(&timers, timer, when); timers_check(&timers, "add");
1299 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1300 timer = malloc(sizeof(*timer));
1302 timer_add(&timers, timer, when); timers_check(&timers, "add");
1303 when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
1304 timer = malloc(sizeof(*timer));
1306 timer_add(&timers, timer, when); timers_check(&timers, "add");
1307 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
1308 timer = malloc(sizeof(*timer));
1310 timer_add(&timers, timer, when); timers_check(&timers, "add");
1311 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
1312 timer = malloc(sizeof(*timer));
1314 timer_add(&timers, timer, when); timers_check(&timers, "add");
1315 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1316 timer = malloc(sizeof(*timer));
1318 timer_add(&timers, timer, when); timers_check(&timers, "add");
1319 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
1320 timer = malloc(sizeof(*timer));
1322 timer_add(&timers, timer, when); timers_check(&timers, "add");
1323 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
1324 timer = malloc(sizeof(*timer));
1326 timer_add(&timers, timer, when); timers_check(&timers, "add");
1327 when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
1328 timer = malloc(sizeof(*timer));
1330 timer_add(&timers, timer, when); timers_check(&timers, "add");
1331 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
1332 timer = malloc(sizeof(*timer));
1334 timer_add(&timers, timer, when); timers_check(&timers, "add");
1335 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1336 timer = malloc(sizeof(*timer));
1338 timer_add(&timers, timer, when); timers_check(&timers, "add");
1339 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
1340 timer = malloc(sizeof(*timer));
1342 timer_add(&timers, timer, when); timers_check(&timers, "add");
1343 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
1344 timer = malloc(sizeof(*timer));
1346 timer_add(&timers, timer, when); timers_check(&timers, "add");
1347 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
1348 timer = malloc(sizeof(*timer));
1350 timer_add(&timers, timer, when); timers_check(&timers, "add");
1351 when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
1352 timer = malloc(sizeof(*timer));
1354 timer_add(&timers, timer, when); timers_check(&timers, "add");
1355 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1356 timer = malloc(sizeof(*timer));
1358 timer_add(&timers, timer, when); timers_check(&timers, "add");
1359 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
1360 timer = malloc(sizeof(*timer));
1362 timer_add(&timers, timer, when); timers_check(&timers, "add");
1363 when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
1364 timer = malloc(sizeof(*timer));
1366 timer_add(&timers, timer, when); timers_check(&timers, "add");
1367 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
1368 timer = malloc(sizeof(*timer));
1370 timer_add(&timers, timer, when); timers_check(&timers, "add");
1371 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1372 timer = malloc(sizeof(*timer));
1374 timer_add(&timers, timer, when); timers_check(&timers, "add");
1375 when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
1376 timer = malloc(sizeof(*timer));
1378 timer_add(&timers, timer, when); timers_check(&timers, "add");
1379 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
1380 timer = malloc(sizeof(*timer));
1382 timer_add(&timers, timer, when); timers_check(&timers, "add");
1383 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
1384 timer = malloc(sizeof(*timer));
1386 timer_add(&timers, timer, when); timers_check(&timers, "add");
1387 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
1388 timer = malloc(sizeof(*timer));
1390 timer_add(&timers, timer, when); timers_check(&timers, "add");
1391 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1392 timer = malloc(sizeof(*timer));
1394 timer_add(&timers, timer, when); timers_check(&timers, "add");
1395 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
1396 timer = malloc(sizeof(*timer));
1398 timer_add(&timers, timer, when); timers_check(&timers, "add");
1399 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
1400 timer = malloc(sizeof(*timer));
1402 timer_add(&timers, timer, when); timers_check(&timers, "add");
1403 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1404 timer = malloc(sizeof(*timer));
1406 timer_add(&timers, timer, when); timers_check(&timers, "add");
1407 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
1408 timer = malloc(sizeof(*timer));
1410 timer_add(&timers, timer, when); timers_check(&timers, "add");
1411 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
1412 timer = malloc(sizeof(*timer));
1414 timer_add(&timers, timer, when); timers_check(&timers, "add");
1415 when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
1416 timer = malloc(sizeof(*timer));
1418 timer_add(&timers, timer, when); timers_check(&timers, "add");
1419 when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
1420 timer = malloc(sizeof(*timer));
1422 timer_add(&timers, timer, when); timers_check(&timers, "add");
1423 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1424 timer = malloc(sizeof(*timer));
1426 timer_add(&timers, timer, when); timers_check(&timers, "add");
1427 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1428 timer = malloc(sizeof(*timer));
1430 timer_add(&timers, timer, when); timers_check(&timers, "add");
1431 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
1432 timer = malloc(sizeof(*timer));
1434 timer_add(&timers, timer, when); timers_check(&timers, "add");
1435 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
1436 timer = malloc(sizeof(*timer));
1438 timer_add(&timers, timer, when); timers_check(&timers, "add");
1439 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
1440 timer = malloc(sizeof(*timer));
1442 timer_add(&timers, timer, when); timers_check(&timers, "add");
1443 when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000;
1444 timer = malloc(sizeof(*timer));
1446 timer_add(&timers, timer, when); timers_check(&timers, "add");
1447 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1448 timer = malloc(sizeof(*timer));
1450 timer_add(&timers, timer, when); timers_check(&timers, "add");
1451 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
1452 timer = malloc(sizeof(*timer));
1454 timer_add(&timers, timer, when); timers_check(&timers, "add");
1455 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
1456 timer = malloc(sizeof(*timer));
1458 timer_add(&timers, timer, when); timers_check(&timers, "add");
1459 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1460 timer = malloc(sizeof(*timer));
1462 timer_add(&timers, timer, when); timers_check(&timers, "add");
1463 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1464 timer = malloc(sizeof(*timer));
1466 timer_add(&timers, timer, when); timers_check(&timers, "add");
1467 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
1468 timer = malloc(sizeof(*timer));
1470 timer_add(&timers, timer, when); timers_check(&timers, "add");
1471 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
1472 timer = malloc(sizeof(*timer));
1474 timer_add(&timers, timer, when); timers_check(&timers, "add");
1475 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
1476 timer = malloc(sizeof(*timer));
1478 timer_add(&timers, timer, when); timers_check(&timers, "add");
1479 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
1480 timer = malloc(sizeof(*timer));
1482 timer_add(&timers, timer, when); timers_check(&timers, "add");
1483 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
1484 timer = malloc(sizeof(*timer));
1486 timer_add(&timers, timer, when); timers_check(&timers, "add");
1487 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1488 timer = malloc(sizeof(*timer));
1490 timer_add(&timers, timer, when); timers_check(&timers, "add");
1491 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1492 timer = malloc(sizeof(*timer));
1494 timer_add(&timers, timer, when); timers_check(&timers, "add");
1495 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
1496 timer = malloc(sizeof(*timer));
1498 timer_add(&timers, timer, when); timers_check(&timers, "add");
1499 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
1500 timer = malloc(sizeof(*timer));
1502 timer_add(&timers, timer, when); timers_check(&timers, "add");
1503 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1504 timer = malloc(sizeof(*timer));
1506 timer_add(&timers, timer, when); timers_check(&timers, "add");
1507 when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000;
1508 timer = malloc(sizeof(*timer));
1510 timer_add(&timers, timer, when); timers_check(&timers, "add");
1511 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1512 timer = malloc(sizeof(*timer));
1514 timer_add(&timers, timer, when); timers_check(&timers, "add");
1515 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1516 timer = malloc(sizeof(*timer));
1518 timer_add(&timers, timer, when); timers_check(&timers, "add");
1519 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1520 timer = malloc(sizeof(*timer));
1522 timer_add(&timers, timer, when); timers_check(&timers, "add");
1523 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1524 timer = malloc(sizeof(*timer));
1526 timer_add(&timers, timer, when); timers_check(&timers, "add");
1527 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
1528 timer = malloc(sizeof(*timer));
1530 timer_add(&timers, timer, when); timers_check(&timers, "add");
1531 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
1532 timer = malloc(sizeof(*timer));
1534 timer_add(&timers, timer, when); timers_check(&timers, "add");
1535 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
1536 timer = malloc(sizeof(*timer));
1538 timer_add(&timers, timer, when); timers_check(&timers, "add");
1539 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
1540 timer = malloc(sizeof(*timer));
1542 timer_add(&timers, timer, when); timers_check(&timers, "add");
1543 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1544 timer = malloc(sizeof(*timer));
1546 timer_add(&timers, timer, when); timers_check(&timers, "add");
1547 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
1548 timer = malloc(sizeof(*timer));
1550 timer_add(&timers, timer, when); timers_check(&timers, "add");
1551 when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
1552 timer = malloc(sizeof(*timer));
1554 timer_add(&timers, timer, when); timers_check(&timers, "add");
1555 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
1556 timer = malloc(sizeof(*timer));
1558 timer_add(&timers, timer, when); timers_check(&timers, "add");
1559 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
1560 timer = malloc(sizeof(*timer));
1562 timer_add(&timers, timer, when); timers_check(&timers, "add");
1563 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1564 timer = malloc(sizeof(*timer));
1566 timer_add(&timers, timer, when); timers_check(&timers, "add");
1567 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
1568 timer = malloc(sizeof(*timer));
1570 timer_add(&timers, timer, when); timers_check(&timers, "add");
1571 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
1572 timer = malloc(sizeof(*timer));
1574 timer_add(&timers, timer, when); timers_check(&timers, "add");
1575 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
1576 timer = malloc(sizeof(*timer));
1578 timer_add(&timers, timer, when); timers_check(&timers, "add");
1579 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1580 timer = malloc(sizeof(*timer));
1582 timer_add(&timers, timer, when); timers_check(&timers, "add");
1583 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
1584 timer = malloc(sizeof(*timer));
1586 timer_add(&timers, timer, when); timers_check(&timers, "add");
1587 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
1588 timer = malloc(sizeof(*timer));
1590 timer_add(&timers, timer, when); timers_check(&timers, "add");
1591 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1592 timer = malloc(sizeof(*timer));
1594 timer_add(&timers, timer, when); timers_check(&timers, "add");
1595 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1596 timer = malloc(sizeof(*timer));
1598 timer_add(&timers, timer, when); timers_check(&timers, "add");
1599 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1600 timer = malloc(sizeof(*timer));
1602 timer_add(&timers, timer, when); timers_check(&timers, "add");
1603 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
1604 timer = malloc(sizeof(*timer));
1606 timer_add(&timers, timer, when); timers_check(&timers, "add");
1607 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
1608 timer = malloc(sizeof(*timer));
1610 timer_add(&timers, timer, when); timers_check(&timers, "add");
1611 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
1612 timer = malloc(sizeof(*timer));
1614 timer_add(&timers, timer, when); timers_check(&timers, "add");
1615 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1616 timer = malloc(sizeof(*timer));
1618 timer_add(&timers, timer, when); timers_check(&timers, "add");
1619 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
1620 timer = malloc(sizeof(*timer));
1622 timer_add(&timers, timer, when); timers_check(&timers, "add");
1623 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
1624 timer = malloc(sizeof(*timer));
1626 timer_add(&timers, timer, when); timers_check(&timers, "add");
1627 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1628 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1629 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1630 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1631 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1632 timer = malloc(sizeof(*timer));
1634 timer_add(&timers, timer, when); timers_check(&timers, "add");
1635 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
1636 timer = malloc(sizeof(*timer));
1638 timer_add(&timers, timer, when); timers_check(&timers, "add");
1639 when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1640 timer = malloc(sizeof(*timer));
1642 timer_add(&timers, timer, when); timers_check(&timers, "add");
1643 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1644 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1645 when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
1646 timer = malloc(sizeof(*timer));
1648 timer_add(&timers, timer, when); timers_check(&timers, "add");
1649 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1650 timer = malloc(sizeof(*timer));
1652 timer_add(&timers, timer, when); timers_check(&timers, "add");
1653 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1654 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1655 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
1656 timer = malloc(sizeof(*timer));
1658 timer_add(&timers, timer, when); timers_check(&timers, "add");
1659 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
1660 timer = malloc(sizeof(*timer));
1662 timer_add(&timers, timer, when); timers_check(&timers, "add");
1663 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1664 timer = malloc(sizeof(*timer));
1666 timer_add(&timers, timer, when); timers_check(&timers, "add");
1667 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
1668 timer = malloc(sizeof(*timer));
1670 timer_add(&timers, timer, when); timers_check(&timers, "add");
1671 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1672 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1673 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1674 timer = malloc(sizeof(*timer));
1676 timer_add(&timers, timer, when); timers_check(&timers, "add");
1677 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
1678 timer = malloc(sizeof(*timer));
1680 timer_add(&timers, timer, when); timers_check(&timers, "add");
1681 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1682 timer = malloc(sizeof(*timer));
1684 timer_add(&timers, timer, when); timers_check(&timers, "add");
1685 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1686 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1687 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1688 timer = malloc(sizeof(*timer));
1690 timer_add(&timers, timer, when); timers_check(&timers, "add");
1691 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1692 timer = malloc(sizeof(*timer));
1694 timer_add(&timers, timer, when); timers_check(&timers, "add");
1695 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1696 timer = malloc(sizeof(*timer));
1698 timer_add(&timers, timer, when); timers_check(&timers, "add");
1699 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1700 timer = malloc(sizeof(*timer));
1702 timer_add(&timers, timer, when); timers_check(&timers, "add");
1703 when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
1704 timer = malloc(sizeof(*timer));
1706 timer_add(&timers, timer, when); timers_check(&timers, "add");
1707 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1708 timer = malloc(sizeof(*timer));
1710 timer_add(&timers, timer, when); timers_check(&timers, "add");
1711 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
1712 timer = malloc(sizeof(*timer));
1714 timer_add(&timers, timer, when); timers_check(&timers, "add");
1715 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1716 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1717 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1718 timer = malloc(sizeof(*timer));
1720 timer_add(&timers, timer, when); timers_check(&timers, "add");
1721 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
1722 timer = malloc(sizeof(*timer));
1724 timer_add(&timers, timer, when); timers_check(&timers, "add");
1725 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
1726 timer = malloc(sizeof(*timer));
1728 timer_add(&timers, timer, when); timers_check(&timers, "add");
1729 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1730 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1731 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1732 timer = malloc(sizeof(*timer));
1734 timer_add(&timers, timer, when); timers_check(&timers, "add");
1735 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
1736 timer = malloc(sizeof(*timer));
1738 timer_add(&timers, timer, when); timers_check(&timers, "add");
1739 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
1740 timer = malloc(sizeof(*timer));
1742 timer_add(&timers, timer, when); timers_check(&timers, "add");
1743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1745 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1746 timer = malloc(sizeof(*timer));
1748 timer_add(&timers, timer, when); timers_check(&timers, "add");
1749 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1750 timer = malloc(sizeof(*timer));
1752 timer_add(&timers, timer, when); timers_check(&timers, "add");
1753 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1754 timer = malloc(sizeof(*timer));
1756 timer_add(&timers, timer, when); timers_check(&timers, "add");
1757 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
1758 timer = malloc(sizeof(*timer));
1760 timer_add(&timers, timer, when); timers_check(&timers, "add");
1761 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1762 timer = malloc(sizeof(*timer));
1764 timer_add(&timers, timer, when); timers_check(&timers, "add");
1765 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
1766 timer = malloc(sizeof(*timer));
1768 timer_add(&timers, timer, when); timers_check(&timers, "add");
1769 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1770 timer = malloc(sizeof(*timer));
1772 timer_add(&timers, timer, when); timers_check(&timers, "add");
1773 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1774 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1775 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1776 timer = malloc(sizeof(*timer));
1778 timer_add(&timers, timer, when); timers_check(&timers, "add");
1779 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
1780 timer = malloc(sizeof(*timer));
1782 timer_add(&timers, timer, when); timers_check(&timers, "add");
1783 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
1784 timer = malloc(sizeof(*timer));
1786 timer_add(&timers, timer, when); timers_check(&timers, "add");
1787 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1788 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1789 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1790 timer = malloc(sizeof(*timer));
1792 timer_add(&timers, timer, when); timers_check(&timers, "add");
1793 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1794 timer = malloc(sizeof(*timer));
1796 timer_add(&timers, timer, when); timers_check(&timers, "add");
1797 when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
1798 timer = malloc(sizeof(*timer));
1800 timer_add(&timers, timer, when); timers_check(&timers, "add");
1801 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1802 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1803 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
1804 timer = malloc(sizeof(*timer));
1806 timer_add(&timers, timer, when); timers_check(&timers, "add");
1807 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
1808 timer = malloc(sizeof(*timer));
1810 timer_add(&timers, timer, when); timers_check(&timers, "add");
1811 when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1812 timer = malloc(sizeof(*timer));
1814 timer_add(&timers, timer, when); timers_check(&timers, "add");
1815 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
1816 timer = malloc(sizeof(*timer));
1818 timer_add(&timers, timer, when); timers_check(&timers, "add");
1819 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1820 timer = malloc(sizeof(*timer));
1822 timer_add(&timers, timer, when); timers_check(&timers, "add");
1823 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1824 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1825 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1826 timer = malloc(sizeof(*timer));
1828 timer_add(&timers, timer, when); timers_check(&timers, "add");
1829 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1830 timer = malloc(sizeof(*timer));
1832 timer_add(&timers, timer, when); timers_check(&timers, "add");
1833 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
1834 timer = malloc(sizeof(*timer));
1836 timer_add(&timers, timer, when); timers_check(&timers, "add");
1837 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1838 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1839 when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
1840 timer = malloc(sizeof(*timer));
1842 timer_add(&timers, timer, when); timers_check(&timers, "add");
1843 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
1844 timer = malloc(sizeof(*timer));
1846 timer_add(&timers, timer, when); timers_check(&timers, "add");
1847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1849 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1850 timer = malloc(sizeof(*timer));
1852 timer_add(&timers, timer, when); timers_check(&timers, "add");
1853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1855 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1856 timer = malloc(sizeof(*timer));
1858 timer_add(&timers, timer, when); timers_check(&timers, "add");
1859 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1860 timer = malloc(sizeof(*timer));
1862 timer_add(&timers, timer, when); timers_check(&timers, "add");
1863 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1864 timer = malloc(sizeof(*timer));
1866 timer_add(&timers, timer, when); timers_check(&timers, "add");
1867 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1868 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1869 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1870 timer = malloc(sizeof(*timer));
1872 timer_add(&timers, timer, when); timers_check(&timers, "add");
1873 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
1874 timer = malloc(sizeof(*timer));
1876 timer_add(&timers, timer, when); timers_check(&timers, "add");
1877 when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
1878 timer = malloc(sizeof(*timer));
1880 timer_add(&timers, timer, when); timers_check(&timers, "add");
1881 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
1882 timer = malloc(sizeof(*timer));
1884 timer_add(&timers, timer, when); timers_check(&timers, "add");
1885 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
1886 timer = malloc(sizeof(*timer));
1888 timer_add(&timers, timer, when); timers_check(&timers, "add");
1889 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1890 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1891 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1892 timer = malloc(sizeof(*timer));
1894 timer_add(&timers, timer, when); timers_check(&timers, "add");
1895 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
1896 timer = malloc(sizeof(*timer));
1898 timer_add(&timers, timer, when); timers_check(&timers, "add");
1899 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
1900 timer = malloc(sizeof(*timer));
1902 timer_add(&timers, timer, when); timers_check(&timers, "add");
1903 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
1904 timer = malloc(sizeof(*timer));
1906 timer_add(&timers, timer, when); timers_check(&timers, "add");
1907 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
1908 timer = malloc(sizeof(*timer));
1910 timer_add(&timers, timer, when); timers_check(&timers, "add");
1911 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
1912 timer = malloc(sizeof(*timer));
1914 timer_add(&timers, timer, when); timers_check(&timers, "add");
1915 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1916 timer = malloc(sizeof(*timer));
1918 timer_add(&timers, timer, when); timers_check(&timers, "add");
1919 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1920 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1921 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1922 timer = malloc(sizeof(*timer));
1924 timer_add(&timers, timer, when); timers_check(&timers, "add");
1925 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
1926 timer = malloc(sizeof(*timer));
1928 timer_add(&timers, timer, when); timers_check(&timers, "add");
1929 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1930 timer = malloc(sizeof(*timer));
1932 timer_add(&timers, timer, when); timers_check(&timers, "add");
1933 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1934 timer = malloc(sizeof(*timer));
1936 timer_add(&timers, timer, when); timers_check(&timers, "add");
1937 when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
1938 timer = malloc(sizeof(*timer));
1940 timer_add(&timers, timer, when); timers_check(&timers, "add");
1941 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1942 timer = malloc(sizeof(*timer));
1944 timer_add(&timers, timer, when); timers_check(&timers, "add");
1945 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1946 timer = malloc(sizeof(*timer));
1948 timer_add(&timers, timer, when); timers_check(&timers, "add");
1949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1951 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
1952 timer = malloc(sizeof(*timer));
1954 timer_add(&timers, timer, when); timers_check(&timers, "add");
1955 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
1956 timer = malloc(sizeof(*timer));
1958 timer_add(&timers, timer, when); timers_check(&timers, "add");
1959 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1960 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1961 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1962 timer = malloc(sizeof(*timer));
1964 timer_add(&timers, timer, when); timers_check(&timers, "add");
1965 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1966 timer = malloc(sizeof(*timer));
1968 timer_add(&timers, timer, when); timers_check(&timers, "add");
1969 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
1970 timer = malloc(sizeof(*timer));
1972 timer_add(&timers, timer, when); timers_check(&timers, "add");
1973 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
1974 timer = malloc(sizeof(*timer));
1976 timer_add(&timers, timer, when); timers_check(&timers, "add");
1977 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
1978 timer = malloc(sizeof(*timer));
1980 timer_add(&timers, timer, when); timers_check(&timers, "add");
1981 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1982 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1983 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1984 timer = malloc(sizeof(*timer));
1986 timer_add(&timers, timer, when); timers_check(&timers, "add");
1987 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1988 timer = malloc(sizeof(*timer));
1990 timer_add(&timers, timer, when); timers_check(&timers, "add");
1991 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
1992 timer = malloc(sizeof(*timer));
1994 timer_add(&timers, timer, when); timers_check(&timers, "add");
1995 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1996 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1997 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
1998 timer = malloc(sizeof(*timer));
2000 timer_add(&timers, timer, when); timers_check(&timers, "add");
2001 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2002 timer = malloc(sizeof(*timer));
2004 timer_add(&timers, timer, when); timers_check(&timers, "add");
2005 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2006 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2007 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
2008 timer = malloc(sizeof(*timer));
2010 timer_add(&timers, timer, when); timers_check(&timers, "add");
2011 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
2012 timer = malloc(sizeof(*timer));
2014 timer_add(&timers, timer, when); timers_check(&timers, "add");
2015 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2016 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2017 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2018 timer = malloc(sizeof(*timer));
2020 timer_add(&timers, timer, when); timers_check(&timers, "add");
2021 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2022 timer = malloc(sizeof(*timer));
2024 timer_add(&timers, timer, when); timers_check(&timers, "add");
2025 when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
2026 timer = malloc(sizeof(*timer));
2028 timer_add(&timers, timer, when); timers_check(&timers, "add");
2029 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
2030 timer = malloc(sizeof(*timer));
2032 timer_add(&timers, timer, when); timers_check(&timers, "add");
2033 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
2034 timer = malloc(sizeof(*timer));
2036 timer_add(&timers, timer, when); timers_check(&timers, "add");
2037 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2038 timer = malloc(sizeof(*timer));
2040 timer_add(&timers, timer, when); timers_check(&timers, "add");
2041 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2042 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2043 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2044 timer = malloc(sizeof(*timer));
2046 timer_add(&timers, timer, when); timers_check(&timers, "add");
2047 when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2048 timer = malloc(sizeof(*timer));
2050 timer_add(&timers, timer, when); timers_check(&timers, "add");
2051 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2052 timer = malloc(sizeof(*timer));
2054 timer_add(&timers, timer, when); timers_check(&timers, "add");
2055 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2056 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2057 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2058 timer = malloc(sizeof(*timer));
2060 timer_add(&timers, timer, when); timers_check(&timers, "add");
2061 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2062 timer = malloc(sizeof(*timer));
2064 timer_add(&timers, timer, when); timers_check(&timers, "add");
2065 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2066 timer = malloc(sizeof(*timer));
2068 timer_add(&timers, timer, when); timers_check(&timers, "add");
2069 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2070 timer = malloc(sizeof(*timer));
2072 timer_add(&timers, timer, when); timers_check(&timers, "add");
2073 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
2074 timer = malloc(sizeof(*timer));
2076 timer_add(&timers, timer, when); timers_check(&timers, "add");
2077 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2078 timer = malloc(sizeof(*timer));
2080 timer_add(&timers, timer, when); timers_check(&timers, "add");
2081 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
2082 timer = malloc(sizeof(*timer));
2084 timer_add(&timers, timer, when); timers_check(&timers, "add");
2085 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
2086 timer = malloc(sizeof(*timer));
2088 timer_add(&timers, timer, when); timers_check(&timers, "add");
2089 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2090 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2091 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2092 timer = malloc(sizeof(*timer));
2094 timer_add(&timers, timer, when); timers_check(&timers, "add");
2095 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
2096 timer = malloc(sizeof(*timer));
2098 timer_add(&timers, timer, when); timers_check(&timers, "add");
2099 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2100 timer = malloc(sizeof(*timer));
2102 timer_add(&timers, timer, when); timers_check(&timers, "add");
2103 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2104 timer = malloc(sizeof(*timer));
2106 timer_add(&timers, timer, when); timers_check(&timers, "add");
2107 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2108 timer = malloc(sizeof(*timer));
2110 timer_add(&timers, timer, when); timers_check(&timers, "add");
2111 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2112 timer = malloc(sizeof(*timer));
2114 timer_add(&timers, timer, when); timers_check(&timers, "add");
2115 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2116 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2117 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2118 timer = malloc(sizeof(*timer));
2120 timer_add(&timers, timer, when); timers_check(&timers, "add");
2121 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
2122 timer = malloc(sizeof(*timer));
2124 timer_add(&timers, timer, when); timers_check(&timers, "add");
2125 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2126 timer = malloc(sizeof(*timer));
2128 timer_add(&timers, timer, when); timers_check(&timers, "add");
2129 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2130 timer = malloc(sizeof(*timer));
2132 timer_add(&timers, timer, when); timers_check(&timers, "add");
2133 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
2134 timer = malloc(sizeof(*timer));
2136 timer_add(&timers, timer, when); timers_check(&timers, "add");
2137 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2138 timer = malloc(sizeof(*timer));
2140 timer_add(&timers, timer, when); timers_check(&timers, "add");
2141 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
2142 timer = malloc(sizeof(*timer));
2144 timer_add(&timers, timer, when); timers_check(&timers, "add");
2145 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
2146 timer = malloc(sizeof(*timer));
2148 timer_add(&timers, timer, when); timers_check(&timers, "add");
2149 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2150 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2151 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2152 timer = malloc(sizeof(*timer));
2154 timer_add(&timers, timer, when); timers_check(&timers, "add");
2155 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
2156 timer = malloc(sizeof(*timer));
2158 timer_add(&timers, timer, when); timers_check(&timers, "add");
2159 when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000;
2160 timer = malloc(sizeof(*timer));
2162 timer_add(&timers, timer, when); timers_check(&timers, "add");
2163 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2164 timer = malloc(sizeof(*timer));
2166 timer_add(&timers, timer, when); timers_check(&timers, "add");
2167 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
2168 timer = malloc(sizeof(*timer));
2170 timer_add(&timers, timer, when); timers_check(&timers, "add");
2171 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2172 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2173 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2174 timer = malloc(sizeof(*timer));
2176 timer_add(&timers, timer, when); timers_check(&timers, "add");
2177 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2178 timer = malloc(sizeof(*timer));
2180 timer_add(&timers, timer, when); timers_check(&timers, "add");
2181 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2182 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2183 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2184 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2185 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2186 timer = malloc(sizeof(*timer));
2188 timer_add(&timers, timer, when); timers_check(&timers, "add");
2189 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2190 timer = malloc(sizeof(*timer));
2192 timer_add(&timers, timer, when); timers_check(&timers, "add");
2193 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2194 timer = malloc(sizeof(*timer));
2196 timer_add(&timers, timer, when); timers_check(&timers, "add");
2197 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2198 timer = malloc(sizeof(*timer));
2200 timer_add(&timers, timer, when); timers_check(&timers, "add");
2201 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2202 timer = malloc(sizeof(*timer));
2204 timer_add(&timers, timer, when); timers_check(&timers, "add");
2205 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2206 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2207 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
2208 timer = malloc(sizeof(*timer));
2210 timer_add(&timers, timer, when); timers_check(&timers, "add");
2211 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
2212 timer = malloc(sizeof(*timer));
2214 timer_add(&timers, timer, when); timers_check(&timers, "add");
2215 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2216 timer = malloc(sizeof(*timer));
2218 timer_add(&timers, timer, when); timers_check(&timers, "add");
2219 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2220 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2221 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
2222 timer = malloc(sizeof(*timer));
2224 timer_add(&timers, timer, when); timers_check(&timers, "add");
2225 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
2226 timer = malloc(sizeof(*timer));
2228 timer_add(&timers, timer, when); timers_check(&timers, "add");
2229 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2230 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2231 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
2232 timer = malloc(sizeof(*timer));
2234 timer_add(&timers, timer, when); timers_check(&timers, "add");
2235 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2236 timer = malloc(sizeof(*timer));
2238 timer_add(&timers, timer, when); timers_check(&timers, "add");
2239 when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
2240 timer = malloc(sizeof(*timer));
2242 timer_add(&timers, timer, when); timers_check(&timers, "add");
2243 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2244 timer = malloc(sizeof(*timer));
2246 timer_add(&timers, timer, when); timers_check(&timers, "add");
2247 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2248 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2249 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2250 timer = malloc(sizeof(*timer));
2252 timer_add(&timers, timer, when); timers_check(&timers, "add");
2253 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2254 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2255 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2256 timer = malloc(sizeof(*timer));
2258 timer_add(&timers, timer, when); timers_check(&timers, "add");
2259 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2260 timer = malloc(sizeof(*timer));
2262 timer_add(&timers, timer, when); timers_check(&timers, "add");
2263 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2264 timer = malloc(sizeof(*timer));
2266 timer_add(&timers, timer, when); timers_check(&timers, "add");
2267 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2268 timer = malloc(sizeof(*timer));
2270 timer_add(&timers, timer, when); timers_check(&timers, "add");
2271 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2272 timer = malloc(sizeof(*timer));
2274 timer_add(&timers, timer, when); timers_check(&timers, "add");
2275 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2276 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2277 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2278 timer = malloc(sizeof(*timer));
2280 timer_add(&timers, timer, when); timers_check(&timers, "add");
2281 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2282 timer = malloc(sizeof(*timer));
2284 timer_add(&timers, timer, when); timers_check(&timers, "add");
2285 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
2286 timer = malloc(sizeof(*timer));
2288 timer_add(&timers, timer, when); timers_check(&timers, "add");
2289 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2290 timer = malloc(sizeof(*timer));
2292 timer_add(&timers, timer, when); timers_check(&timers, "add");
2293 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2294 timer = malloc(sizeof(*timer));
2296 timer_add(&timers, timer, when); timers_check(&timers, "add");
2297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2299 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2300 timer = malloc(sizeof(*timer));
2302 timer_add(&timers, timer, when); timers_check(&timers, "add");
2303 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2304 timer = malloc(sizeof(*timer));
2306 timer_add(&timers, timer, when); timers_check(&timers, "add");
2307 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2308 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2309 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2310 timer = malloc(sizeof(*timer));
2312 timer_add(&timers, timer, when); timers_check(&timers, "add");
2313 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2314 timer = malloc(sizeof(*timer));
2316 timer_add(&timers, timer, when); timers_check(&timers, "add");
2317 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2318 timer = malloc(sizeof(*timer));
2320 timer_add(&timers, timer, when); timers_check(&timers, "add");
2321 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2322 timer = malloc(sizeof(*timer));
2324 timer_add(&timers, timer, when); timers_check(&timers, "add");
2325 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
2326 timer = malloc(sizeof(*timer));
2328 timer_add(&timers, timer, when); timers_check(&timers, "add");
2329 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2330 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2331 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
2332 timer = malloc(sizeof(*timer));
2334 timer_add(&timers, timer, when); timers_check(&timers, "add");
2335 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2336 timer = malloc(sizeof(*timer));
2338 timer_add(&timers, timer, when); timers_check(&timers, "add");
2339 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2340 timer = malloc(sizeof(*timer));
2342 timer_add(&timers, timer, when); timers_check(&timers, "add");
2343 when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
2344 timer = malloc(sizeof(*timer));
2346 timer_add(&timers, timer, when); timers_check(&timers, "add");
2347 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2348 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2349 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2350 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2351 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2352 timer = malloc(sizeof(*timer));
2354 timer_add(&timers, timer, when); timers_check(&timers, "add");
2355 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2356 timer = malloc(sizeof(*timer));
2358 timer_add(&timers, timer, when); timers_check(&timers, "add");
2359 when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
2360 timer = malloc(sizeof(*timer));
2362 timer_add(&timers, timer, when); timers_check(&timers, "add");
2363 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2364 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2365 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2366 timer = malloc(sizeof(*timer));
2368 timer_add(&timers, timer, when); timers_check(&timers, "add");
2369 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2370 timer = malloc(sizeof(*timer));
2372 timer_add(&timers, timer, when); timers_check(&timers, "add");
2373 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2374 timer = malloc(sizeof(*timer));
2376 timer_add(&timers, timer, when); timers_check(&timers, "add");
2377 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2378 timer = malloc(sizeof(*timer));
2380 timer_add(&timers, timer, when); timers_check(&timers, "add");
2381 when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2382 timer = malloc(sizeof(*timer));
2384 timer_add(&timers, timer, when); timers_check(&timers, "add");
2385 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2386 timer = malloc(sizeof(*timer));
2388 timer_add(&timers, timer, when); timers_check(&timers, "add");
2389 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2390 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2391 when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000;
2392 timer = malloc(sizeof(*timer));
2394 timer_add(&timers, timer, when); timers_check(&timers, "add");
2395 when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000;
2396 timer = malloc(sizeof(*timer));
2398 timer_add(&timers, timer, when); timers_check(&timers, "add");
2399 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
2400 timer = malloc(sizeof(*timer));
2402 timer_add(&timers, timer, when); timers_check(&timers, "add");
2403 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2404 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2405 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2406 timer = malloc(sizeof(*timer));
2408 timer_add(&timers, timer, when); timers_check(&timers, "add");
2409 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2410 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2411 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2412 timer = malloc(sizeof(*timer));
2414 timer_add(&timers, timer, when); timers_check(&timers, "add");
2415 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
2416 timer = malloc(sizeof(*timer));
2418 timer_add(&timers, timer, when); timers_check(&timers, "add");
2419 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2420 timer = malloc(sizeof(*timer));
2422 timer_add(&timers, timer, when); timers_check(&timers, "add");
2423 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2424 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2425 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2426 timer = malloc(sizeof(*timer));
2428 timer_add(&timers, timer, when); timers_check(&timers, "add");
2429 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
2430 timer = malloc(sizeof(*timer));
2432 timer_add(&timers, timer, when); timers_check(&timers, "add");
2433 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2434 timer = malloc(sizeof(*timer));
2436 timer_add(&timers, timer, when); timers_check(&timers, "add");
2437 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2438 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2439 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
2440 timer = malloc(sizeof(*timer));
2442 timer_add(&timers, timer, when); timers_check(&timers, "add");
2443 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
2444 timer = malloc(sizeof(*timer));
2446 timer_add(&timers, timer, when); timers_check(&timers, "add");
2447 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2448 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2449 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2450 timer = malloc(sizeof(*timer));
2452 timer_add(&timers, timer, when); timers_check(&timers, "add");
2453 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
2454 timer = malloc(sizeof(*timer));
2456 timer_add(&timers, timer, when); timers_check(&timers, "add");
2457 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2458 timer = malloc(sizeof(*timer));
2460 timer_add(&timers, timer, when); timers_check(&timers, "add");
2461 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2462 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2463 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
2464 timer = malloc(sizeof(*timer));
2466 timer_add(&timers, timer, when); timers_check(&timers, "add");
2467 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2468 timer = malloc(sizeof(*timer));
2470 timer_add(&timers, timer, when); timers_check(&timers, "add");
2471 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2472 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2473 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
2474 timer = malloc(sizeof(*timer));
2476 timer_add(&timers, timer, when); timers_check(&timers, "add");
2477 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2478 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2479 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
2480 timer = malloc(sizeof(*timer));
2482 timer_add(&timers, timer, when); timers_check(&timers, "add");
2483 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2484 timer = malloc(sizeof(*timer));
2486 timer_add(&timers, timer, when); timers_check(&timers, "add");
2487 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
2488 timer = malloc(sizeof(*timer));
2490 timer_add(&timers, timer, when); timers_check(&timers, "add");
2491 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2492 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2493 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2494 timer = malloc(sizeof(*timer));
2496 timer_add(&timers, timer, when); timers_check(&timers, "add");
2497 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2498 timer = malloc(sizeof(*timer));
2500 timer_add(&timers, timer, when); timers_check(&timers, "add");
2501 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
2502 timer = malloc(sizeof(*timer));
2504 timer_add(&timers, timer, when); timers_check(&timers, "add");
2505 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2506 timer = malloc(sizeof(*timer));
2508 timer_add(&timers, timer, when); timers_check(&timers, "add");
2509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2511 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
2512 timer = malloc(sizeof(*timer));
2514 timer_add(&timers, timer, when); timers_check(&timers, "add");
2515 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2516 timer = malloc(sizeof(*timer));
2518 timer_add(&timers, timer, when); timers_check(&timers, "add");
2519 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2520 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2521 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
2522 timer = malloc(sizeof(*timer));
2524 timer_add(&timers, timer, when); timers_check(&timers, "add");
2525 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2526 timer = malloc(sizeof(*timer));
2528 timer_add(&timers, timer, when); timers_check(&timers, "add");
2529 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2530 timer = malloc(sizeof(*timer));
2532 timer_add(&timers, timer, when); timers_check(&timers, "add");
2533 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2534 timer = malloc(sizeof(*timer));
2536 timer_add(&timers, timer, when); timers_check(&timers, "add");
2537 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
2538 timer = malloc(sizeof(*timer));
2540 timer_add(&timers, timer, when); timers_check(&timers, "add");
2541 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2542 timer = malloc(sizeof(*timer));
2544 timer_add(&timers, timer, when); timers_check(&timers, "add");
2545 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2546 timer = malloc(sizeof(*timer));
2548 timer_add(&timers, timer, when); timers_check(&timers, "add");
2549 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2550 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2551 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2552 timer = malloc(sizeof(*timer));
2554 timer_add(&timers, timer, when); timers_check(&timers, "add");
2555 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2556 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2557 when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000;
2558 timer = malloc(sizeof(*timer));
2560 timer_add(&timers, timer, when); timers_check(&timers, "add");
2561 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2562 timer = malloc(sizeof(*timer));
2564 timer_add(&timers, timer, when); timers_check(&timers, "add");
2565 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
2566 timer = malloc(sizeof(*timer));
2568 timer_add(&timers, timer, when); timers_check(&timers, "add");
2569 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
2570 timer = malloc(sizeof(*timer));
2572 timer_add(&timers, timer, when); timers_check(&timers, "add");
2573 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2574 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2575 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2576 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2577 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2578 timer = malloc(sizeof(*timer));
2580 timer_add(&timers, timer, when); timers_check(&timers, "add");
2581 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2582 timer = malloc(sizeof(*timer));
2584 timer_add(&timers, timer, when); timers_check(&timers, "add");
2585 when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
2586 timer = malloc(sizeof(*timer));
2588 timer_add(&timers, timer, when); timers_check(&timers, "add");
2589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2591 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2592 timer = malloc(sizeof(*timer));
2594 timer_add(&timers, timer, when); timers_check(&timers, "add");
2595 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2596 timer = malloc(sizeof(*timer));
2598 timer_add(&timers, timer, when); timers_check(&timers, "add");
2599 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2600 timer = malloc(sizeof(*timer));
2602 timer_add(&timers, timer, when); timers_check(&timers, "add");
2603 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2604 timer = malloc(sizeof(*timer));
2606 timer_add(&timers, timer, when); timers_check(&timers, "add");
2607 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2608 timer = malloc(sizeof(*timer));
2610 timer_add(&timers, timer, when); timers_check(&timers, "add");
2611 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2612 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2613 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2614 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2615 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2616 timer = malloc(sizeof(*timer));
2618 timer_add(&timers, timer, when); timers_check(&timers, "add");
2619 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2620 timer = malloc(sizeof(*timer));
2622 timer_add(&timers, timer, when); timers_check(&timers, "add");
2623 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2624 timer = malloc(sizeof(*timer));
2626 timer_add(&timers, timer, when); timers_check(&timers, "add");
2627 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2628 timer = malloc(sizeof(*timer));
2630 timer_add(&timers, timer, when); timers_check(&timers, "add");
2631 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2632 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2633 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
2634 timer = malloc(sizeof(*timer));
2636 timer_add(&timers, timer, when); timers_check(&timers, "add");
2637 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
2638 timer = malloc(sizeof(*timer));
2640 timer_add(&timers, timer, when); timers_check(&timers, "add");
2641 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2642 timer = malloc(sizeof(*timer));
2644 timer_add(&timers, timer, when); timers_check(&timers, "add");
2645 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2646 timer = malloc(sizeof(*timer));
2648 timer_add(&timers, timer, when); timers_check(&timers, "add");
2649 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2650 timer = malloc(sizeof(*timer));
2652 timer_add(&timers, timer, when); timers_check(&timers, "add");
2653 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2654 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2655 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2656 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2657 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2658 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2659 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
2660 timer = malloc(sizeof(*timer));
2662 timer_add(&timers, timer, when); timers_check(&timers, "add");
2663 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2664 timer = malloc(sizeof(*timer));
2666 timer_add(&timers, timer, when); timers_check(&timers, "add");
2667 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2668 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2669 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2670 timer = malloc(sizeof(*timer));
2672 timer_add(&timers, timer, when); timers_check(&timers, "add");
2673 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2674 timer = malloc(sizeof(*timer));
2676 timer_add(&timers, timer, when); timers_check(&timers, "add");
2677 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2678 timer = malloc(sizeof(*timer));
2680 timer_add(&timers, timer, when); timers_check(&timers, "add");
2681 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2682 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2683 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
2684 timer = malloc(sizeof(*timer));
2686 timer_add(&timers, timer, when); timers_check(&timers, "add");
2687 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
2688 timer = malloc(sizeof(*timer));
2690 timer_add(&timers, timer, when); timers_check(&timers, "add");
2691 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2692 timer = malloc(sizeof(*timer));
2694 timer_add(&timers, timer, when); timers_check(&timers, "add");
2695 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2696 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2697 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2698 timer = malloc(sizeof(*timer));
2700 timer_add(&timers, timer, when); timers_check(&timers, "add");
2701 when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000;
2702 timer = malloc(sizeof(*timer));
2704 timer_add(&timers, timer, when); timers_check(&timers, "add");
2705 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
2706 timer = malloc(sizeof(*timer));
2708 timer_add(&timers, timer, when); timers_check(&timers, "add");
2709 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
2710 timer = malloc(sizeof(*timer));
2712 timer_add(&timers, timer, when); timers_check(&timers, "add");
2713 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2714 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2715 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2716 timer = malloc(sizeof(*timer));
2718 timer_add(&timers, timer, when); timers_check(&timers, "add");
2719 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2720 timer = malloc(sizeof(*timer));
2722 timer_add(&timers, timer, when); timers_check(&timers, "add");
2723 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2724 timer = malloc(sizeof(*timer));
2726 timer_add(&timers, timer, when); timers_check(&timers, "add");
2727 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2728 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2729 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2730 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2731 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2732 timer = malloc(sizeof(*timer));
2734 timer_add(&timers, timer, when); timers_check(&timers, "add");
2735 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
2736 timer = malloc(sizeof(*timer));
2738 timer_add(&timers, timer, when); timers_check(&timers, "add");
2739 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2740 timer = malloc(sizeof(*timer));
2742 timer_add(&timers, timer, when); timers_check(&timers, "add");
2743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2745 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2746 timer = malloc(sizeof(*timer));
2748 timer_add(&timers, timer, when); timers_check(&timers, "add");
2749 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
2750 timer = malloc(sizeof(*timer));
2752 timer_add(&timers, timer, when); timers_check(&timers, "add");
2753 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2754 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2755 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2756 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2757 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2758 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2759 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2760 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2761 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2762 timer = malloc(sizeof(*timer));
2764 timer_add(&timers, timer, when); timers_check(&timers, "add");
2765 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2766 timer = malloc(sizeof(*timer));
2768 timer_add(&timers, timer, when); timers_check(&timers, "add");
2769 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2770 timer = malloc(sizeof(*timer));
2772 timer_add(&timers, timer, when); timers_check(&timers, "add");
2773 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
2774 timer = malloc(sizeof(*timer));
2776 timer_add(&timers, timer, when); timers_check(&timers, "add");
2777 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
2778 timer = malloc(sizeof(*timer));
2780 timer_add(&timers, timer, when); timers_check(&timers, "add");
2781 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2782 timer = malloc(sizeof(*timer));
2784 timer_add(&timers, timer, when); timers_check(&timers, "add");
2785 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2786 timer = malloc(sizeof(*timer));
2788 timer_add(&timers, timer, when); timers_check(&timers, "add");
2789 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2790 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2791 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2792 timer = malloc(sizeof(*timer));
2794 timer_add(&timers, timer, when); timers_check(&timers, "add");
2795 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2796 timer = malloc(sizeof(*timer));
2798 timer_add(&timers, timer, when); timers_check(&timers, "add");
2799 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
2800 timer = malloc(sizeof(*timer));
2802 timer_add(&timers, timer, when); timers_check(&timers, "add");
2803 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2804 timer = malloc(sizeof(*timer));
2806 timer_add(&timers, timer, when); timers_check(&timers, "add");
2807 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
2808 timer = malloc(sizeof(*timer));
2810 timer_add(&timers, timer, when); timers_check(&timers, "add");
2811 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2812 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2813 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2814 timer = malloc(sizeof(*timer));
2816 timer_add(&timers, timer, when); timers_check(&timers, "add");
2817 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2818 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2819 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2820 timer = malloc(sizeof(*timer));
2822 timer_add(&timers, timer, when); timers_check(&timers, "add");
2823 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2824 timer = malloc(sizeof(*timer));
2826 timer_add(&timers, timer, when); timers_check(&timers, "add");
2827 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2828 timer = malloc(sizeof(*timer));
2830 timer_add(&timers, timer, when); timers_check(&timers, "add");
2831 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2832 timer = malloc(sizeof(*timer));
2834 timer_add(&timers, timer, when); timers_check(&timers, "add");
2835 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
2836 timer = malloc(sizeof(*timer));
2838 timer_add(&timers, timer, when); timers_check(&timers, "add");
2839 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2840 timer = malloc(sizeof(*timer));
2842 timer_add(&timers, timer, when); timers_check(&timers, "add");
2843 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2844 timer = malloc(sizeof(*timer));
2846 timer_add(&timers, timer, when); timers_check(&timers, "add");
2847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2849 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2850 timer = malloc(sizeof(*timer));
2852 timer_add(&timers, timer, when); timers_check(&timers, "add");
2853 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2854 timer = malloc(sizeof(*timer));
2856 timer_add(&timers, timer, when); timers_check(&timers, "add");
2857 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
2858 timer = malloc(sizeof(*timer));
2860 timer_add(&timers, timer, when); timers_check(&timers, "add");
2861 when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
2862 timer = malloc(sizeof(*timer));
2864 timer_add(&timers, timer, when); timers_check(&timers, "add");
2865 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2866 timer = malloc(sizeof(*timer));
2868 timer_add(&timers, timer, when); timers_check(&timers, "add");
2869 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2870 timer = malloc(sizeof(*timer));
2872 timer_add(&timers, timer, when); timers_check(&timers, "add");
2873 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2874 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2875 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2876 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2877 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2878 timer = malloc(sizeof(*timer));
2880 timer_add(&timers, timer, when); timers_check(&timers, "add");
2881 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2882 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2883 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
2884 timer = malloc(sizeof(*timer));
2886 timer_add(&timers, timer, when); timers_check(&timers, "add");
2887 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2888 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2889 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
2890 timer = malloc(sizeof(*timer));
2892 timer_add(&timers, timer, when); timers_check(&timers, "add");
2893 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2894 timer = malloc(sizeof(*timer));
2896 timer_add(&timers, timer, when); timers_check(&timers, "add");
2897 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
2898 timer = malloc(sizeof(*timer));
2900 timer_add(&timers, timer, when); timers_check(&timers, "add");
2901 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2902 timer = malloc(sizeof(*timer));
2904 timer_add(&timers, timer, when); timers_check(&timers, "add");
2905 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
2906 timer = malloc(sizeof(*timer));
2908 timer_add(&timers, timer, when); timers_check(&timers, "add");
2909 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2910 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2911 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2912 timer = malloc(sizeof(*timer));
2914 timer_add(&timers, timer, when); timers_check(&timers, "add");
2915 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2916 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2917 when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
2918 timer = malloc(sizeof(*timer));
2920 timer_add(&timers, timer, when); timers_check(&timers, "add");
2921 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2922 timer = malloc(sizeof(*timer));
2924 timer_add(&timers, timer, when); timers_check(&timers, "add");
2925 when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000;
2926 timer = malloc(sizeof(*timer));
2928 timer_add(&timers, timer, when); timers_check(&timers, "add");
2929 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
2930 timer = malloc(sizeof(*timer));
2932 timer_add(&timers, timer, when); timers_check(&timers, "add");
2933 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2934 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2935 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2936 timer = malloc(sizeof(*timer));
2938 timer_add(&timers, timer, when); timers_check(&timers, "add");
2939 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2940 timer = malloc(sizeof(*timer));
2942 timer_add(&timers, timer, when); timers_check(&timers, "add");
2943 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2944 timer = malloc(sizeof(*timer));
2946 timer_add(&timers, timer, when); timers_check(&timers, "add");
2947 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2948 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2951 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2952 timer = malloc(sizeof(*timer));
2954 timer_add(&timers, timer, when); timers_check(&timers, "add");
2955 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2956 timer = malloc(sizeof(*timer));
2958 timer_add(&timers, timer, when); timers_check(&timers, "add");
2959 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2960 timer = malloc(sizeof(*timer));
2962 timer_add(&timers, timer, when); timers_check(&timers, "add");
2963 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2964 timer = malloc(sizeof(*timer));
2966 timer_add(&timers, timer, when); timers_check(&timers, "add");
2967 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2968 timer = malloc(sizeof(*timer));
2970 timer_add(&timers, timer, when); timers_check(&timers, "add");
2971 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2972 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2973 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
2974 timer = malloc(sizeof(*timer));
2976 timer_add(&timers, timer, when); timers_check(&timers, "add");
2977 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2978 timer = malloc(sizeof(*timer));
2980 timer_add(&timers, timer, when); timers_check(&timers, "add");
2981 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
2982 timer = malloc(sizeof(*timer));
2984 timer_add(&timers, timer, when); timers_check(&timers, "add");
2985 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
2986 timer = malloc(sizeof(*timer));
2988 timer_add(&timers, timer, when); timers_check(&timers, "add");
2989 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2990 timer = malloc(sizeof(*timer));
2992 timer_add(&timers, timer, when); timers_check(&timers, "add");
2993 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2994 timer = malloc(sizeof(*timer));
2996 timer_add(&timers, timer, when); timers_check(&timers, "add");
2997 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2998 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2999 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3000 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3001 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3002 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3003 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3004 timer = malloc(sizeof(*timer));
3006 timer_add(&timers, timer, when); timers_check(&timers, "add");
3007 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3008 timer = malloc(sizeof(*timer));
3010 timer_add(&timers, timer, when); timers_check(&timers, "add");
3011 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3012 timer = malloc(sizeof(*timer));
3014 timer_add(&timers, timer, when); timers_check(&timers, "add");
3015 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3016 timer = malloc(sizeof(*timer));
3018 timer_add(&timers, timer, when); timers_check(&timers, "add");
3019 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3020 timer = malloc(sizeof(*timer));
3022 timer_add(&timers, timer, when); timers_check(&timers, "add");
3023 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
3024 timer = malloc(sizeof(*timer));
3026 timer_add(&timers, timer, when); timers_check(&timers, "add");
3027 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
3028 timer = malloc(sizeof(*timer));
3030 timer_add(&timers, timer, when); timers_check(&timers, "add");
3031 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3032 timer = malloc(sizeof(*timer));
3034 timer_add(&timers, timer, when); timers_check(&timers, "add");
3035 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3036 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3037 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3038 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3039 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3040 timer = malloc(sizeof(*timer));
3042 timer_add(&timers, timer, when); timers_check(&timers, "add");
3043 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3044 timer = malloc(sizeof(*timer));
3046 timer_add(&timers, timer, when); timers_check(&timers, "add");
3047 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3048 timer = malloc(sizeof(*timer));
3050 timer_add(&timers, timer, when); timers_check(&timers, "add");
3051 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3052 timer = malloc(sizeof(*timer));
3054 timer_add(&timers, timer, when); timers_check(&timers, "add");
3055 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3056 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3057 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3058 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3059 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3060 timer = malloc(sizeof(*timer));
3062 timer_add(&timers, timer, when); timers_check(&timers, "add");
3063 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
3064 timer = malloc(sizeof(*timer));
3066 timer_add(&timers, timer, when); timers_check(&timers, "add");
3067 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3068 timer = malloc(sizeof(*timer));
3070 timer_add(&timers, timer, when); timers_check(&timers, "add");
3071 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3072 timer = malloc(sizeof(*timer));
3074 timer_add(&timers, timer, when); timers_check(&timers, "add");
3075 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3076 timer = malloc(sizeof(*timer));
3078 timer_add(&timers, timer, when); timers_check(&timers, "add");
3079 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3080 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3081 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3082 timer = malloc(sizeof(*timer));
3084 timer_add(&timers, timer, when); timers_check(&timers, "add");
3085 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3086 timer = malloc(sizeof(*timer));
3088 timer_add(&timers, timer, when); timers_check(&timers, "add");
3089 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3090 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3091 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3092 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3093 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3094 timer = malloc(sizeof(*timer));
3096 timer_add(&timers, timer, when); timers_check(&timers, "add");
3097 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
3098 timer = malloc(sizeof(*timer));
3100 timer_add(&timers, timer, when); timers_check(&timers, "add");
3101 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3102 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3103 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3104 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3105 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
3106 timer = malloc(sizeof(*timer));
3108 timer_add(&timers, timer, when); timers_check(&timers, "add");
3109 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3110 timer = malloc(sizeof(*timer));
3112 timer_add(&timers, timer, when); timers_check(&timers, "add");
3113 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
3114 timer = malloc(sizeof(*timer));
3116 timer_add(&timers, timer, when); timers_check(&timers, "add");
3117 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3118 timer = malloc(sizeof(*timer));
3120 timer_add(&timers, timer, when); timers_check(&timers, "add");
3121 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3122 timer = malloc(sizeof(*timer));
3124 timer_add(&timers, timer, when); timers_check(&timers, "add");
3125 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3126 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3127 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3128 timer = malloc(sizeof(*timer));
3130 timer_add(&timers, timer, when); timers_check(&timers, "add");
3131 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3132 timer = malloc(sizeof(*timer));
3134 timer_add(&timers, timer, when); timers_check(&timers, "add");
3135 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3136 timer = malloc(sizeof(*timer));
3138 timer_add(&timers, timer, when); timers_check(&timers, "add");
3139 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3140 timer = malloc(sizeof(*timer));
3142 timer_add(&timers, timer, when); timers_check(&timers, "add");
3143 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
3144 timer = malloc(sizeof(*timer));
3146 timer_add(&timers, timer, when); timers_check(&timers, "add");
3147 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3148 timer = malloc(sizeof(*timer));
3150 timer_add(&timers, timer, when); timers_check(&timers, "add");
3151 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
3152 timer = malloc(sizeof(*timer));
3154 timer_add(&timers, timer, when); timers_check(&timers, "add");
3155 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3156 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3157 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3158 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3159 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3160 timer = malloc(sizeof(*timer));
3162 timer_add(&timers, timer, when); timers_check(&timers, "add");
3163 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
3164 timer = malloc(sizeof(*timer));
3166 timer_add(&timers, timer, when); timers_check(&timers, "add");
3167 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3168 timer = malloc(sizeof(*timer));
3170 timer_add(&timers, timer, when); timers_check(&timers, "add");
3171 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3172 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3173 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3174 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3175 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3176 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3177 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3178 timer = malloc(sizeof(*timer));
3180 timer_add(&timers, timer, when); timers_check(&timers, "add");
3181 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3182 timer = malloc(sizeof(*timer));
3184 timer_add(&timers, timer, when); timers_check(&timers, "add");
3185 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
3186 timer = malloc(sizeof(*timer));
3188 timer_add(&timers, timer, when); timers_check(&timers, "add");
3189 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3190 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3191 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3192 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3193 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3194 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3195 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
3196 timer = malloc(sizeof(*timer));
3198 timer_add(&timers, timer, when); timers_check(&timers, "add");
3199 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
3200 timer = malloc(sizeof(*timer));
3202 timer_add(&timers, timer, when); timers_check(&timers, "add");
3203 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3204 timer = malloc(sizeof(*timer));
3206 timer_add(&timers, timer, when); timers_check(&timers, "add");
3207 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3208 timer = malloc(sizeof(*timer));
3210 timer_add(&timers, timer, when); timers_check(&timers, "add");
3211 when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
3212 timer = malloc(sizeof(*timer));
3214 timer_add(&timers, timer, when); timers_check(&timers, "add");
3215 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3216 timer = malloc(sizeof(*timer));
3218 timer_add(&timers, timer, when); timers_check(&timers, "add");
3219 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3220 timer = malloc(sizeof(*timer));
3222 timer_add(&timers, timer, when); timers_check(&timers, "add");
3223 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3224 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3225 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3226 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3227 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3228 timer = malloc(sizeof(*timer));
3230 timer_add(&timers, timer, when); timers_check(&timers, "add");
3231 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3232 timer = malloc(sizeof(*timer));
3234 timer_add(&timers, timer, when); timers_check(&timers, "add");
3235 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
3236 timer = malloc(sizeof(*timer));
3238 timer_add(&timers, timer, when); timers_check(&timers, "add");
3239 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3240 timer = malloc(sizeof(*timer));
3242 timer_add(&timers, timer, when); timers_check(&timers, "add");
3243 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3244 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3245 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
3246 timer = malloc(sizeof(*timer));
3248 timer_add(&timers, timer, when); timers_check(&timers, "add");
3249 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3250 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3251 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
3252 timer = malloc(sizeof(*timer));
3254 timer_add(&timers, timer, when); timers_check(&timers, "add");
3255 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3256 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3257 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
3258 timer = malloc(sizeof(*timer));
3260 timer_add(&timers, timer, when); timers_check(&timers, "add");
3261 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3262 timer = malloc(sizeof(*timer));
3264 timer_add(&timers, timer, when); timers_check(&timers, "add");
3265 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3266 timer = malloc(sizeof(*timer));
3268 timer_add(&timers, timer, when); timers_check(&timers, "add");
3269 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3270 timer = malloc(sizeof(*timer));
3272 timer_add(&timers, timer, when); timers_check(&timers, "add");
3273 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3274 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3275 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
3276 timer = malloc(sizeof(*timer));
3278 timer_add(&timers, timer, when); timers_check(&timers, "add");
3279 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
3280 timer = malloc(sizeof(*timer));
3282 timer_add(&timers, timer, when); timers_check(&timers, "add");
3283 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3284 timer = malloc(sizeof(*timer));
3286 timer_add(&timers, timer, when); timers_check(&timers, "add");
3287 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3288 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3289 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3290 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3291 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3292 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3293 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3294 timer = malloc(sizeof(*timer));
3296 timer_add(&timers, timer, when); timers_check(&timers, "add");
3297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3299 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3300 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3301 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
3302 timer = malloc(sizeof(*timer));
3304 timer_add(&timers, timer, when); timers_check(&timers, "add");
3305 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3306 timer = malloc(sizeof(*timer));
3308 timer_add(&timers, timer, when); timers_check(&timers, "add");
3309 when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000;
3310 timer = malloc(sizeof(*timer));
3312 timer_add(&timers, timer, when); timers_check(&timers, "add");
3313 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
3314 timer = malloc(sizeof(*timer));
3316 timer_add(&timers, timer, when); timers_check(&timers, "add");
3317 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3318 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3319 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
3320 timer = malloc(sizeof(*timer));
3322 timer_add(&timers, timer, when); timers_check(&timers, "add");
3323 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3324 timer = malloc(sizeof(*timer));
3326 timer_add(&timers, timer, when); timers_check(&timers, "add");
3327 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
3328 timer = malloc(sizeof(*timer));
3330 timer_add(&timers, timer, when); timers_check(&timers, "add");
3331 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3332 timer = malloc(sizeof(*timer));
3334 timer_add(&timers, timer, when); timers_check(&timers, "add");
3335 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3336 timer = malloc(sizeof(*timer));
3338 timer_add(&timers, timer, when); timers_check(&timers, "add");
3339 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
3340 timer = malloc(sizeof(*timer));
3342 timer_add(&timers, timer, when); timers_check(&timers, "add");
3343 when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
3344 timer = malloc(sizeof(*timer));
3346 timer_add(&timers, timer, when); timers_check(&timers, "add");
3347 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3348 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3349 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3350 timer = malloc(sizeof(*timer));
3352 timer_add(&timers, timer, when); timers_check(&timers, "add");
3353 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3354 timer = malloc(sizeof(*timer));
3356 timer_add(&timers, timer, when); timers_check(&timers, "add");
3357 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3358 timer = malloc(sizeof(*timer));
3360 timer_add(&timers, timer, when); timers_check(&timers, "add");
3361 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3362 timer = malloc(sizeof(*timer));
3364 timer_add(&timers, timer, when); timers_check(&timers, "add");
3365 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3366 timer = malloc(sizeof(*timer));
3368 timer_add(&timers, timer, when); timers_check(&timers, "add");
3369 when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
3370 timer = malloc(sizeof(*timer));
3372 timer_add(&timers, timer, when); timers_check(&timers, "add");
3373 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
3374 timer = malloc(sizeof(*timer));
3376 timer_add(&timers, timer, when); timers_check(&timers, "add");
3377 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3378 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3379 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3380 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3381 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3382 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3383 when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
3384 timer = malloc(sizeof(*timer));
3386 timer_add(&timers, timer, when); timers_check(&timers, "add");
3387 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3388 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3389 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3390 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3391 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3392 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3393 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3394 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3395 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3396 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3397 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3398 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3399 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3400 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3401 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
3402 timer = malloc(sizeof(*timer));
3404 timer_add(&timers, timer, when); timers_check(&timers, "add");
3405 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
3406 timer = malloc(sizeof(*timer));
3408 timer_add(&timers, timer, when); timers_check(&timers, "add");
3409 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3410 timer = malloc(sizeof(*timer));
3412 timer_add(&timers, timer, when); timers_check(&timers, "add");
3413 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3414 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3415 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3416 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3417 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3418 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3419 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3420 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3421 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3422 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3423 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3424 timer = malloc(sizeof(*timer));
3426 timer_add(&timers, timer, when); timers_check(&timers, "add");
3427 when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000;
3428 timer = malloc(sizeof(*timer));
3430 timer_add(&timers, timer, when); timers_check(&timers, "add");
3431 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3432 timer = malloc(sizeof(*timer));
3434 timer_add(&timers, timer, when); timers_check(&timers, "add");
3435 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3436 timer = malloc(sizeof(*timer));
3438 timer_add(&timers, timer, when); timers_check(&timers, "add");
3439 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3440 timer = malloc(sizeof(*timer));
3442 timer_add(&timers, timer, when); timers_check(&timers, "add");
3443 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3444 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3445 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3446 timer = malloc(sizeof(*timer));
3448 timer_add(&timers, timer, when); timers_check(&timers, "add");
3449 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
3450 timer = malloc(sizeof(*timer));
3452 timer_add(&timers, timer, when); timers_check(&timers, "add");
3453 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3454 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3455 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
3456 timer = malloc(sizeof(*timer));
3458 timer_add(&timers, timer, when); timers_check(&timers, "add");
3459 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
3460 timer = malloc(sizeof(*timer));
3462 timer_add(&timers, timer, when); timers_check(&timers, "add");
3463 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
3464 timer = malloc(sizeof(*timer));
3466 timer_add(&timers, timer, when); timers_check(&timers, "add");
3467 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3468 timer = malloc(sizeof(*timer));
3470 timer_add(&timers, timer, when); timers_check(&timers, "add");
3471 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3472 timer = malloc(sizeof(*timer));
3474 timer_add(&timers, timer, when); timers_check(&timers, "add");
3475 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3476 timer = malloc(sizeof(*timer));
3478 timer_add(&timers, timer, when); timers_check(&timers, "add");
3479 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3480 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3481 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3482 timer = malloc(sizeof(*timer));
3484 timer_add(&timers, timer, when); timers_check(&timers, "add");
3485 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
3486 timer = malloc(sizeof(*timer));
3488 timer_add(&timers, timer, when); timers_check(&timers, "add");
3489 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
3490 timer = malloc(sizeof(*timer));
3492 timer_add(&timers, timer, when); timers_check(&timers, "add");
3493 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3494 timer = malloc(sizeof(*timer));
3496 timer_add(&timers, timer, when); timers_check(&timers, "add");
3497 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
3498 timer = malloc(sizeof(*timer));
3500 timer_add(&timers, timer, when); timers_check(&timers, "add");
3501 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3502 timer = malloc(sizeof(*timer));
3504 timer_add(&timers, timer, when); timers_check(&timers, "add");
3505 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
3506 timer = malloc(sizeof(*timer));
3508 timer_add(&timers, timer, when); timers_check(&timers, "add");
3509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3511 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
3512 timer = malloc(sizeof(*timer));
3514 timer_add(&timers, timer, when); timers_check(&timers, "add");
3515 when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
3516 timer = malloc(sizeof(*timer));
3518 timer_add(&timers, timer, when); timers_check(&timers, "add");
3519 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3520 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3521 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3522 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3523 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
3524 timer = malloc(sizeof(*timer));
3526 timer_add(&timers, timer, when); timers_check(&timers, "add");
3527 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3528 timer = malloc(sizeof(*timer));
3530 timer_add(&timers, timer, when); timers_check(&timers, "add");
3531 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
3532 timer = malloc(sizeof(*timer));
3534 timer_add(&timers, timer, when); timers_check(&timers, "add");
3535 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3536 timer = malloc(sizeof(*timer));
3538 timer_add(&timers, timer, when); timers_check(&timers, "add");
3539 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
3540 timer = malloc(sizeof(*timer));
3542 timer_add(&timers, timer, when); timers_check(&timers, "add");
3543 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
3544 timer = malloc(sizeof(*timer));
3546 timer_add(&timers, timer, when); timers_check(&timers, "add");
3547 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3548 timer = malloc(sizeof(*timer));
3550 timer_add(&timers, timer, when); timers_check(&timers, "add");
3551 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3552 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3553 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3554 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3555 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3556 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3557 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
3558 timer = malloc(sizeof(*timer));
3560 timer_add(&timers, timer, when); timers_check(&timers, "add");
3561 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3562 timer = malloc(sizeof(*timer));
3564 timer_add(&timers, timer, when); timers_check(&timers, "add");
3565 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
3566 timer = malloc(sizeof(*timer));
3568 timer_add(&timers, timer, when); timers_check(&timers, "add");
3569 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3570 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3571 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3572 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3573 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3574 timer = malloc(sizeof(*timer));
3576 timer_add(&timers, timer, when); timers_check(&timers, "add");
3577 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3578 timer = malloc(sizeof(*timer));
3580 timer_add(&timers, timer, when); timers_check(&timers, "add");
3581 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3582 timer = malloc(sizeof(*timer));
3584 timer_add(&timers, timer, when); timers_check(&timers, "add");
3585 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3586 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3587 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3588 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3591 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3592 timer = malloc(sizeof(*timer));
3594 timer_add(&timers, timer, when); timers_check(&timers, "add");
3595 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
3596 timer = malloc(sizeof(*timer));
3598 timer_add(&timers, timer, when); timers_check(&timers, "add");
3599 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3600 timer = malloc(sizeof(*timer));
3602 timer_add(&timers, timer, when); timers_check(&timers, "add");
3603 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
3604 timer = malloc(sizeof(*timer));
3606 timer_add(&timers, timer, when); timers_check(&timers, "add");
3607 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3608 timer = malloc(sizeof(*timer));
3610 timer_add(&timers, timer, when); timers_check(&timers, "add");
3611 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3612 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3613 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3614 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3615 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3616 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3617 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3618 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3619 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3620 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3621 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3622 timer = malloc(sizeof(*timer));
3624 timer_add(&timers, timer, when); timers_check(&timers, "add");
3625 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
3626 timer = malloc(sizeof(*timer));
3628 timer_add(&timers, timer, when); timers_check(&timers, "add");
3629 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3630 timer = malloc(sizeof(*timer));
3632 timer_add(&timers, timer, when); timers_check(&timers, "add");
3633 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
3634 timer = malloc(sizeof(*timer));
3636 timer_add(&timers, timer, when); timers_check(&timers, "add");
3637 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
3638 timer = malloc(sizeof(*timer));
3640 timer_add(&timers, timer, when); timers_check(&timers, "add");
3641 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3642 timer = malloc(sizeof(*timer));
3644 timer_add(&timers, timer, when); timers_check(&timers, "add");
3645 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3646 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3647 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3648 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3649 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3650 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3651 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3652 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3653 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3654 timer = malloc(sizeof(*timer));
3656 timer_add(&timers, timer, when); timers_check(&timers, "add");
3657 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3658 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3659 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3660 timer = malloc(sizeof(*timer));
3662 timer_add(&timers, timer, when); timers_check(&timers, "add");
3663 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3664 timer = malloc(sizeof(*timer));
3666 timer_add(&timers, timer, when); timers_check(&timers, "add");
3667 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3668 timer = malloc(sizeof(*timer));
3670 timer_add(&timers, timer, when); timers_check(&timers, "add");
3671 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3672 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3673 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3674 timer = malloc(sizeof(*timer));
3676 timer_add(&timers, timer, when); timers_check(&timers, "add");
3677 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3678 timer = malloc(sizeof(*timer));
3680 timer_add(&timers, timer, when); timers_check(&timers, "add");
3681 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
3682 timer = malloc(sizeof(*timer));
3684 timer_add(&timers, timer, when); timers_check(&timers, "add");
3685 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3686 timer = malloc(sizeof(*timer));
3688 timer_add(&timers, timer, when); timers_check(&timers, "add");
3689 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3690 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3691 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3692 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3693 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3694 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3695 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
3696 timer = malloc(sizeof(*timer));
3698 timer_add(&timers, timer, when); timers_check(&timers, "add");
3699 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
3700 timer = malloc(sizeof(*timer));
3702 timer_add(&timers, timer, when); timers_check(&timers, "add");
3703 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3704 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3705 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3706 timer = malloc(sizeof(*timer));
3708 timer_add(&timers, timer, when); timers_check(&timers, "add");
3709 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3710 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3711 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3712 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3713 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3714 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3715 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3716 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3717 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3718 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3719 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3720 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3721 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3722 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3723 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3724 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3725 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3726 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3727 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
3728 timer = malloc(sizeof(*timer));
3730 timer_add(&timers, timer, when); timers_check(&timers, "add");
3731 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3732 timer = malloc(sizeof(*timer));
3734 timer_add(&timers, timer, when); timers_check(&timers, "add");
3735 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3736 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3737 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3738 timer = malloc(sizeof(*timer));
3740 timer_add(&timers, timer, when); timers_check(&timers, "add");
3741 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
3742 timer = malloc(sizeof(*timer));
3744 timer_add(&timers, timer, when); timers_check(&timers, "add");
3745 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3746 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3747 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3748 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3749 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3750 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3751 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3752 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3753 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3754 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3755 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
3756 timer = malloc(sizeof(*timer));
3758 timer_add(&timers, timer, when); timers_check(&timers, "add");
3759 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
3760 timer = malloc(sizeof(*timer));
3762 timer_add(&timers, timer, when); timers_check(&timers, "add");
3763 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3764 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3765 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3766 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3767 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3768 timer = malloc(sizeof(*timer));
3770 timer_add(&timers, timer, when); timers_check(&timers, "add");
3771 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3772 timer = malloc(sizeof(*timer));
3774 timer_add(&timers, timer, when); timers_check(&timers, "add");
3775 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3776 timer = malloc(sizeof(*timer));
3778 timer_add(&timers, timer, when); timers_check(&timers, "add");
3779 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
3780 timer = malloc(sizeof(*timer));
3782 timer_add(&timers, timer, when); timers_check(&timers, "add");
3783 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3784 timer = malloc(sizeof(*timer));
3786 timer_add(&timers, timer, when); timers_check(&timers, "add");
3787 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3788 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3789 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3790 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3791 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3792 timer = malloc(sizeof(*timer));
3794 timer_add(&timers, timer, when); timers_check(&timers, "add");
3795 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3796 timer = malloc(sizeof(*timer));
3798 timer_add(&timers, timer, when); timers_check(&timers, "add");
3799 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3800 timer = malloc(sizeof(*timer));
3802 timer_add(&timers, timer, when); timers_check(&timers, "add");
3803 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3804 timer = malloc(sizeof(*timer));
3806 timer_add(&timers, timer, when); timers_check(&timers, "add");
3807 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3808 timer = malloc(sizeof(*timer));
3810 timer_add(&timers, timer, when); timers_check(&timers, "add");
3811 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3812 timer = malloc(sizeof(*timer));
3814 timer_add(&timers, timer, when); timers_check(&timers, "add");
3815 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3816 timer = malloc(sizeof(*timer));
3818 timer_add(&timers, timer, when); timers_check(&timers, "add");
3819 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
3820 timer = malloc(sizeof(*timer));
3822 timer_add(&timers, timer, when); timers_check(&timers, "add");
3823 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3824 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3825 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3826 timer = malloc(sizeof(*timer));
3828 timer_add(&timers, timer, when); timers_check(&timers, "add");
3829 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
3830 timer = malloc(sizeof(*timer));
3832 timer_add(&timers, timer, when); timers_check(&timers, "add");
3833 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3834 timer = malloc(sizeof(*timer));
3836 timer_add(&timers, timer, when); timers_check(&timers, "add");
3837 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
3838 timer = malloc(sizeof(*timer));
3840 timer_add(&timers, timer, when); timers_check(&timers, "add");
3841 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
3842 timer = malloc(sizeof(*timer));
3844 timer_add(&timers, timer, when); timers_check(&timers, "add");
3845 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3846 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3849 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3850 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3851 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3852 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3855 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
3856 timer = malloc(sizeof(*timer));
3858 timer_add(&timers, timer, when); timers_check(&timers, "add");
3859 when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
3860 timer = malloc(sizeof(*timer));
3862 timer_add(&timers, timer, when); timers_check(&timers, "add");
3863 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
3864 timer = malloc(sizeof(*timer));
3866 timer_add(&timers, timer, when); timers_check(&timers, "add");
3867 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3868 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3869 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
3870 timer = malloc(sizeof(*timer));
3872 timer_add(&timers, timer, when); timers_check(&timers, "add");
3873 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3874 timer = malloc(sizeof(*timer));
3876 timer_add(&timers, timer, when); timers_check(&timers, "add");
3877 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
3878 timer = malloc(sizeof(*timer));
3880 timer_add(&timers, timer, when); timers_check(&timers, "add");
3881 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3882 timer = malloc(sizeof(*timer));
3884 timer_add(&timers, timer, when); timers_check(&timers, "add");
3885 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3886 timer = malloc(sizeof(*timer));
3888 timer_add(&timers, timer, when); timers_check(&timers, "add");
3889 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3890 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3891 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
3892 timer = malloc(sizeof(*timer));
3894 timer_add(&timers, timer, when); timers_check(&timers, "add");
3895 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3896 timer = malloc(sizeof(*timer));
3898 timer_add(&timers, timer, when); timers_check(&timers, "add");
3899 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3900 timer = malloc(sizeof(*timer));
3902 timer_add(&timers, timer, when); timers_check(&timers, "add");
3903 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3904 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3905 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3906 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3907 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3908 timer = malloc(sizeof(*timer));
3910 timer_add(&timers, timer, when); timers_check(&timers, "add");
3911 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3912 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3913 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3914 timer = malloc(sizeof(*timer));
3916 timer_add(&timers, timer, when); timers_check(&timers, "add");
3917 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
3918 timer = malloc(sizeof(*timer));
3920 timer_add(&timers, timer, when); timers_check(&timers, "add");
3921 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3922 timer = malloc(sizeof(*timer));
3924 timer_add(&timers, timer, when); timers_check(&timers, "add");
3925 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3926 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3927 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3928 timer = malloc(sizeof(*timer));
3930 timer_add(&timers, timer, when); timers_check(&timers, "add");
3931 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3932 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3933 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3934 timer = malloc(sizeof(*timer));
3936 timer_add(&timers, timer, when); timers_check(&timers, "add");
3937 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3938 timer = malloc(sizeof(*timer));
3940 timer_add(&timers, timer, when); timers_check(&timers, "add");
3941 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3942 timer = malloc(sizeof(*timer));
3944 timer_add(&timers, timer, when); timers_check(&timers, "add");
3945 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3946 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3947 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3948 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3951 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3952 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3953 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3954 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3955 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3956 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3957 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3958 timer = malloc(sizeof(*timer));
3960 timer_add(&timers, timer, when); timers_check(&timers, "add");
3961 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3962 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3963 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3964 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3965 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3966 timer = malloc(sizeof(*timer));
3968 timer_add(&timers, timer, when); timers_check(&timers, "add");
3969 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3970 timer = malloc(sizeof(*timer));
3972 timer_add(&timers, timer, when); timers_check(&timers, "add");
3973 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
3974 timer = malloc(sizeof(*timer));
3976 timer_add(&timers, timer, when); timers_check(&timers, "add");
3977 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
3978 timer = malloc(sizeof(*timer));
3980 timer_add(&timers, timer, when); timers_check(&timers, "add");
3981 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
3982 timer = malloc(sizeof(*timer));
3984 timer_add(&timers, timer, when); timers_check(&timers, "add");
3985 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
3986 timer = malloc(sizeof(*timer));
3988 timer_add(&timers, timer, when); timers_check(&timers, "add");
3989 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3990 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3991 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3992 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3993 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3994 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3995 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3996 timer = malloc(sizeof(*timer));
3998 timer_add(&timers, timer, when); timers_check(&timers, "add");
3999 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
4000 timer = malloc(sizeof(*timer));
4002 timer_add(&timers, timer, when); timers_check(&timers, "add");
4003 when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
4004 timer = malloc(sizeof(*timer));
4006 timer_add(&timers, timer, when); timers_check(&timers, "add");
4007 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4008 timer = malloc(sizeof(*timer));
4010 timer_add(&timers, timer, when); timers_check(&timers, "add");
4011 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4012 timer = malloc(sizeof(*timer));
4014 timer_add(&timers, timer, when); timers_check(&timers, "add");
4015 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4016 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4017 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
4018 timer = malloc(sizeof(*timer));
4020 timer_add(&timers, timer, when); timers_check(&timers, "add");
4021 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4022 timer = malloc(sizeof(*timer));
4024 timer_add(&timers, timer, when); timers_check(&timers, "add");
4025 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4026 timer = malloc(sizeof(*timer));
4028 timer_add(&timers, timer, when); timers_check(&timers, "add");
4029 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4030 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4031 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4032 timer = malloc(sizeof(*timer));
4034 timer_add(&timers, timer, when); timers_check(&timers, "add");
4035 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4036 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4037 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
4038 timer = malloc(sizeof(*timer));
4040 timer_add(&timers, timer, when); timers_check(&timers, "add");
4041 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4042 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4043 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4044 timer = malloc(sizeof(*timer));
4046 timer_add(&timers, timer, when); timers_check(&timers, "add");
4047 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4048 timer = malloc(sizeof(*timer));
4050 timer_add(&timers, timer, when); timers_check(&timers, "add");
4051 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
4052 timer = malloc(sizeof(*timer));
4054 timer_add(&timers, timer, when); timers_check(&timers, "add");
4055 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4056 timer = malloc(sizeof(*timer));
4058 timer_add(&timers, timer, when); timers_check(&timers, "add");
4059 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
4060 timer = malloc(sizeof(*timer));
4062 timer_add(&timers, timer, when); timers_check(&timers, "add");
4063 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4064 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4065 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4066 timer = malloc(sizeof(*timer));
4068 timer_add(&timers, timer, when); timers_check(&timers, "add");
4069 when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
4070 timer = malloc(sizeof(*timer));
4072 timer_add(&timers, timer, when); timers_check(&timers, "add");
4073 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4074 timer = malloc(sizeof(*timer));
4076 timer_add(&timers, timer, when); timers_check(&timers, "add");
4077 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4078 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4079 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4080 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4081 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
4082 timer = malloc(sizeof(*timer));
4084 timer_add(&timers, timer, when); timers_check(&timers, "add");
4085 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4086 timer = malloc(sizeof(*timer));
4088 timer_add(&timers, timer, when); timers_check(&timers, "add");
4089 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
4090 timer = malloc(sizeof(*timer));
4092 timer_add(&timers, timer, when); timers_check(&timers, "add");
4093 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4094 timer = malloc(sizeof(*timer));
4096 timer_add(&timers, timer, when); timers_check(&timers, "add");
4097 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
4098 timer = malloc(sizeof(*timer));
4100 timer_add(&timers, timer, when); timers_check(&timers, "add");
4101 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
4102 timer = malloc(sizeof(*timer));
4104 timer_add(&timers, timer, when); timers_check(&timers, "add");
4105 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
4106 timer = malloc(sizeof(*timer));
4108 timer_add(&timers, timer, when); timers_check(&timers, "add");
4109 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4110 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4111 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
4112 timer = malloc(sizeof(*timer));
4114 timer_add(&timers, timer, when); timers_check(&timers, "add");
4115 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
4116 timer = malloc(sizeof(*timer));
4118 timer_add(&timers, timer, when); timers_check(&timers, "add");
4119 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
4120 timer = malloc(sizeof(*timer));
4122 timer_add(&timers, timer, when); timers_check(&timers, "add");
4123 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4124 timer = malloc(sizeof(*timer));
4126 timer_add(&timers, timer, when); timers_check(&timers, "add");
4127 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
4128 timer = malloc(sizeof(*timer));
4130 timer_add(&timers, timer, when); timers_check(&timers, "add");
4131 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4132 timer = malloc(sizeof(*timer));
4134 timer_add(&timers, timer, when); timers_check(&timers, "add");
4135 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
4136 timer = malloc(sizeof(*timer));
4138 timer_add(&timers, timer, when); timers_check(&timers, "add");
4139 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4140 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4141 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4142 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4143 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4144 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4145 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4146 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4147 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4148 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4149 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
4150 timer = malloc(sizeof(*timer));
4152 timer_add(&timers, timer, when); timers_check(&timers, "add");
4153 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
4154 timer = malloc(sizeof(*timer));
4156 timer_add(&timers, timer, when); timers_check(&timers, "add");
4157 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4158 timer = malloc(sizeof(*timer));
4160 timer_add(&timers, timer, when); timers_check(&timers, "add");
4161 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4162 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4163 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
4164 timer = malloc(sizeof(*timer));
4166 timer_add(&timers, timer, when); timers_check(&timers, "add");
4167 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4168 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4169 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4170 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4171 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4172 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4173 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4174 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4175 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
4176 timer = malloc(sizeof(*timer));
4178 timer_add(&timers, timer, when); timers_check(&timers, "add");
4179 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
4180 timer = malloc(sizeof(*timer));
4182 timer_add(&timers, timer, when); timers_check(&timers, "add");
4183 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
4184 timer = malloc(sizeof(*timer));
4186 timer_add(&timers, timer, when); timers_check(&timers, "add");
4187 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4188 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4189 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4190 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4191 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
4192 timer = malloc(sizeof(*timer));
4194 timer_add(&timers, timer, when); timers_check(&timers, "add");
4195 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
4196 timer = malloc(sizeof(*timer));
4198 timer_add(&timers, timer, when); timers_check(&timers, "add");
4199 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4200 timer = malloc(sizeof(*timer));
4202 timer_add(&timers, timer, when); timers_check(&timers, "add");
4203 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4204 timer = malloc(sizeof(*timer));
4206 timer_add(&timers, timer, when); timers_check(&timers, "add");
4207 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
4208 timer = malloc(sizeof(*timer));
4210 timer_add(&timers, timer, when); timers_check(&timers, "add");
4211 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
4212 timer = malloc(sizeof(*timer));
4214 timer_add(&timers, timer, when); timers_check(&timers, "add");
4215 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
4216 timer = malloc(sizeof(*timer));
4218 timer_add(&timers, timer, when); timers_check(&timers, "add");
4219 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4220 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4221 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4222 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4223 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4224 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4225 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4226 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4227 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4228 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4229 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4230 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4231 when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
4232 timer = malloc(sizeof(*timer));
4234 timer_add(&timers, timer, when); timers_check(&timers, "add");
4235 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4236 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4237 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4238 timer = malloc(sizeof(*timer));
4240 timer_add(&timers, timer, when); timers_check(&timers, "add");
4241 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
4242 timer = malloc(sizeof(*timer));
4244 timer_add(&timers, timer, when); timers_check(&timers, "add");
4245 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4246 timer = malloc(sizeof(*timer));
4248 timer_add(&timers, timer, when); timers_check(&timers, "add");
4249 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4250 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4251 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4252 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4253 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4254 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4255 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
4256 timer = malloc(sizeof(*timer));
4258 timer_add(&timers, timer, when); timers_check(&timers, "add");
4259 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
4260 timer = malloc(sizeof(*timer));
4262 timer_add(&timers, timer, when); timers_check(&timers, "add");
4263 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
4264 timer = malloc(sizeof(*timer));
4266 timer_add(&timers, timer, when); timers_check(&timers, "add");
4267 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4268 timer = malloc(sizeof(*timer));
4270 timer_add(&timers, timer, when); timers_check(&timers, "add");
4271 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4272 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4273 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4274 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4275 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
4276 timer = malloc(sizeof(*timer));
4278 timer_add(&timers, timer, when); timers_check(&timers, "add");
4279 when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
4280 timer = malloc(sizeof(*timer));
4282 timer_add(&timers, timer, when); timers_check(&timers, "add");
4283 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
4284 timer = malloc(sizeof(*timer));
4286 timer_add(&timers, timer, when); timers_check(&timers, "add");
4287 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4288 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4289 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4290 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4291 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4292 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4293 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4294 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4295 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4296 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4299 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
4300 timer = malloc(sizeof(*timer));
4302 timer_add(&timers, timer, when); timers_check(&timers, "add");
4303 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4304 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4305 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4306 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4307 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4308 timer = malloc(sizeof(*timer));
4310 timer_add(&timers, timer, when); timers_check(&timers, "add");
4311 when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000;
4312 timer = malloc(sizeof(*timer));
4314 timer_add(&timers, timer, when); timers_check(&timers, "add");
4315 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4316 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4317 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4318 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4319 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4320 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4321 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4322 timer = malloc(sizeof(*timer));
4324 timer_add(&timers, timer, when); timers_check(&timers, "add");
4325 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
4326 timer = malloc(sizeof(*timer));
4328 timer_add(&timers, timer, when); timers_check(&timers, "add");
4329 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4330 timer = malloc(sizeof(*timer));
4332 timer_add(&timers, timer, when); timers_check(&timers, "add");
4333 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
4334 timer = malloc(sizeof(*timer));
4336 timer_add(&timers, timer, when); timers_check(&timers, "add");
4337 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
4338 timer = malloc(sizeof(*timer));
4340 timer_add(&timers, timer, when); timers_check(&timers, "add");
4341 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
4342 timer = malloc(sizeof(*timer));
4344 timer_add(&timers, timer, when); timers_check(&timers, "add");
4345 when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
4346 timer = malloc(sizeof(*timer));
4348 timer_add(&timers, timer, when); timers_check(&timers, "add");
4349 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4350 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4351 when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000;
4352 timer = malloc(sizeof(*timer));
4354 timer_add(&timers, timer, when); timers_check(&timers, "add");
4355 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
4356 timer = malloc(sizeof(*timer));
4358 timer_add(&timers, timer, when); timers_check(&timers, "add");
4359 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
4360 timer = malloc(sizeof(*timer));
4362 timer_add(&timers, timer, when); timers_check(&timers, "add");
4363 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
4364 timer = malloc(sizeof(*timer));
4366 timer_add(&timers, timer, when); timers_check(&timers, "add");
4367 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4368 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4369 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4370 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4371 when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
4372 timer = malloc(sizeof(*timer));
4374 timer_add(&timers, timer, when); timers_check(&timers, "add");
4375 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4376 timer = malloc(sizeof(*timer));
4378 timer_add(&timers, timer, when); timers_check(&timers, "add");
4379 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
4380 timer = malloc(sizeof(*timer));
4382 timer_add(&timers, timer, when); timers_check(&timers, "add");
4383 when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
4384 timer = malloc(sizeof(*timer));
4386 timer_add(&timers, timer, when); timers_check(&timers, "add");
4387 when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
4388 timer = malloc(sizeof(*timer));
4390 timer_add(&timers, timer, when); timers_check(&timers, "add");
4391 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
4392 timer = malloc(sizeof(*timer));
4394 timer_add(&timers, timer, when); timers_check(&timers, "add");
4395 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4396 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4397 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4398 timer = malloc(sizeof(*timer));
4400 timer_add(&timers, timer, when); timers_check(&timers, "add");
4401 when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
4402 timer = malloc(sizeof(*timer));
4404 timer_add(&timers, timer, when); timers_check(&timers, "add");
4405 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
4406 timer = malloc(sizeof(*timer));
4408 timer_add(&timers, timer, when); timers_check(&timers, "add");
4409 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4410 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4411 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4412 timer = malloc(sizeof(*timer));
4414 timer_add(&timers, timer, when); timers_check(&timers, "add");
4415 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
4416 timer = malloc(sizeof(*timer));
4418 timer_add(&timers, timer, when); timers_check(&timers, "add");
4419 when.ts.tv_sec = 0; when.ts.tv_nsec = 307000000;
4420 timer = malloc(sizeof(*timer));
4422 timer_add(&timers, timer, when); timers_check(&timers, "add");
4423 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4424 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4425 when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
4426 timer = malloc(sizeof(*timer));
4428 timer_add(&timers, timer, when); timers_check(&timers, "add");
4429 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
4430 timer = malloc(sizeof(*timer));
4432 timer_add(&timers, timer, when); timers_check(&timers, "add");
4433 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
4434 timer = malloc(sizeof(*timer));
4436 timer_add(&timers, timer, when); timers_check(&timers, "add");
4437 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4438 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4439 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4440 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4441 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
4442 timer = malloc(sizeof(*timer));
4444 timer_add(&timers, timer, when); timers_check(&timers, "add");
4445 when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
4446 timer = malloc(sizeof(*timer));
4448 timer_add(&timers, timer, when); timers_check(&timers, "add");
4449 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4450 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4451 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4452 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4453 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
4454 timer = malloc(sizeof(*timer));
4456 timer_add(&timers, timer, when); timers_check(&timers, "add");
4457 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
4458 timer = malloc(sizeof(*timer));
4460 timer_add(&timers, timer, when); timers_check(&timers, "add");
4461 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4462 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4463 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4464 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4465 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4466 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4467 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
4468 timer = malloc(sizeof(*timer));
4470 timer_add(&timers, timer, when); timers_check(&timers, "add");
4471 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4472 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4473 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4474 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4475 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4476 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4477 when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000;
4478 timer = malloc(sizeof(*timer));
4480 timer_add(&timers, timer, when); timers_check(&timers, "add");
4481 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4482 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4483 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
4484 timer = malloc(sizeof(*timer));
4486 timer_add(&timers, timer, when); timers_check(&timers, "add");
4487 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
4488 timer = malloc(sizeof(*timer));
4490 timer_add(&timers, timer, when); timers_check(&timers, "add");
4491 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
4492 timer = malloc(sizeof(*timer));
4494 timer_add(&timers, timer, when); timers_check(&timers, "add");
4495 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
4496 timer = malloc(sizeof(*timer));
4498 timer_add(&timers, timer, when); timers_check(&timers, "add");
4499 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4500 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4501 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4502 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4503 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4504 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4505 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4506 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4507 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4508 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4511 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4512 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4513 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4514 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4515 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4516 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4517 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4518 timer = malloc(sizeof(*timer));
4520 timer_add(&timers, timer, when); timers_check(&timers, "add");
4521 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
4522 timer = malloc(sizeof(*timer));
4524 timer_add(&timers, timer, when); timers_check(&timers, "add");
4525 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
4526 timer = malloc(sizeof(*timer));
4528 timer_add(&timers, timer, when); timers_check(&timers, "add");
4529 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4530 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4531 when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000;
4532 timer = malloc(sizeof(*timer));
4534 timer_add(&timers, timer, when); timers_check(&timers, "add");
4535 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
4536 timer = malloc(sizeof(*timer));
4538 timer_add(&timers, timer, when); timers_check(&timers, "add");
4539 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4540 timer = malloc(sizeof(*timer));
4542 timer_add(&timers, timer, when); timers_check(&timers, "add");
4543 when.ts.tv_sec = 0; when.ts.tv_nsec = 270000000;
4544 timer = malloc(sizeof(*timer));
4546 timer_add(&timers, timer, when); timers_check(&timers, "add");
4547 when.ts.tv_sec = 0; when.ts.tv_nsec = 237000000;
4548 timer = malloc(sizeof(*timer));
4550 timer_add(&timers, timer, when); timers_check(&timers, "add");
4551 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4552 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4553 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4554 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4555 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4556 timer = malloc(sizeof(*timer));
4558 timer_add(&timers, timer, when); timers_check(&timers, "add");
4559 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4560 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4561 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4562 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4563 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
4564 timer = malloc(sizeof(*timer));
4566 timer_add(&timers, timer, when); timers_check(&timers, "add");
4567 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4568 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4569 when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
4570 timer = malloc(sizeof(*timer));
4572 timer_add(&timers, timer, when); timers_check(&timers, "add");
4573 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
4574 timer = malloc(sizeof(*timer));
4576 timer_add(&timers, timer, when); timers_check(&timers, "add");
4577 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4578 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4579 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4580 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4581 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
4582 timer = malloc(sizeof(*timer));
4584 timer_add(&timers, timer, when); timers_check(&timers, "add");
4585 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
4586 timer = malloc(sizeof(*timer));
4588 timer_add(&timers, timer, when); timers_check(&timers, "add");
4589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4591 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4592 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4593 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4594 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4595 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
4596 timer = malloc(sizeof(*timer));
4598 timer_add(&timers, timer, when); timers_check(&timers, "add");
4599 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
4600 timer = malloc(sizeof(*timer));
4602 timer_add(&timers, timer, when); timers_check(&timers, "add");
4603 when.ts.tv_sec = 0; when.ts.tv_nsec = 117000000;
4604 timer = malloc(sizeof(*timer));
4606 timer_add(&timers, timer, when); timers_check(&timers, "add");
4607 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
4608 timer = malloc(sizeof(*timer));
4610 timer_add(&timers, timer, when); timers_check(&timers, "add");
4611 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4612 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4613 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
4614 timer = malloc(sizeof(*timer));
4616 timer_add(&timers, timer, when); timers_check(&timers, "add");
4617 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
4618 timer = malloc(sizeof(*timer));
4620 timer_add(&timers, timer, when); timers_check(&timers, "add");
4621 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
4622 timer = malloc(sizeof(*timer));
4624 timer_add(&timers, timer, when); timers_check(&timers, "add");
4625 when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000;
4626 timer = malloc(sizeof(*timer));
4628 timer_add(&timers, timer, when); timers_check(&timers, "add");
4629 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
4630 timer = malloc(sizeof(*timer));
4632 timer_add(&timers, timer, when); timers_check(&timers, "add");
4633 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4634 timer = malloc(sizeof(*timer));
4636 timer_add(&timers, timer, when); timers_check(&timers, "add");
4637 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4638 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4639 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4640 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4641 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4642 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4643 when.ts.tv_sec = 0; when.ts.tv_nsec = 312000000;
4644 timer = malloc(sizeof(*timer));
4646 timer_add(&timers, timer, when); timers_check(&timers, "add");
4647 when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
4648 timer = malloc(sizeof(*timer));
4650 timer_add(&timers, timer, when); timers_check(&timers, "add");
4651 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4652 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4653 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
4654 timer = malloc(sizeof(*timer));
4656 timer_add(&timers, timer, when); timers_check(&timers, "add");
4657 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
4658 timer = malloc(sizeof(*timer));
4660 timer_add(&timers, timer, when); timers_check(&timers, "add");
4661 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
4662 timer = malloc(sizeof(*timer));
4664 timer_add(&timers, timer, when); timers_check(&timers, "add");
4665 when.ts.tv_sec = 0; when.ts.tv_nsec = 273000000;
4666 timer = malloc(sizeof(*timer));
4668 timer_add(&timers, timer, when); timers_check(&timers, "add");
4669 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4670 timer = malloc(sizeof(*timer));
4672 timer_add(&timers, timer, when); timers_check(&timers, "add");
4673 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4674 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4675 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4676 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4677 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
4678 timer = malloc(sizeof(*timer));
4680 timer_add(&timers, timer, when); timers_check(&timers, "add");
4681 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
4682 timer = malloc(sizeof(*timer));
4684 timer_add(&timers, timer, when); timers_check(&timers, "add");
4685 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4686 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4687 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4688 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4689 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
4690 timer = malloc(sizeof(*timer));
4692 timer_add(&timers, timer, when); timers_check(&timers, "add");
4693 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
4694 timer = malloc(sizeof(*timer));
4696 timer_add(&timers, timer, when); timers_check(&timers, "add");
4697 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
4698 timer = malloc(sizeof(*timer));
4700 timer_add(&timers, timer, when); timers_check(&timers, "add");
4701 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
4702 timer = malloc(sizeof(*timer));
4704 timer_add(&timers, timer, when); timers_check(&timers, "add");
4705 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4706 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4707 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4708 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4709 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4710 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4711 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4712 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4713 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4714 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4715 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4716 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4717 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4718 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4719 when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000;
4720 timer = malloc(sizeof(*timer));
4722 timer_add(&timers, timer, when); timers_check(&timers, "add");
4723 when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
4724 timer = malloc(sizeof(*timer));
4726 timer_add(&timers, timer, when); timers_check(&timers, "add");
4727 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
4728 timer = malloc(sizeof(*timer));
4730 timer_add(&timers, timer, when); timers_check(&timers, "add");
4731 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4732 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4733 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4734 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4735 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
4736 timer = malloc(sizeof(*timer));
4738 timer_add(&timers, timer, when); timers_check(&timers, "add");
4739 when.ts.tv_sec = 0; when.ts.tv_nsec = 317000000;
4740 timer = malloc(sizeof(*timer));
4742 timer_add(&timers, timer, when); timers_check(&timers, "add");
4743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4745 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4746 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4747 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4748 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4749 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4750 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4751 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4752 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4753 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4754 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4755 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4756 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4757 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4758 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4759 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4760 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4761 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4762 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4763 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4764 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4765 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4766 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4767 when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
4768 timer = malloc(sizeof(*timer));
4770 timer_add(&timers, timer, when); timers_check(&timers, "add");
4771 when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
4772 timer = malloc(sizeof(*timer));
4774 timer_add(&timers, timer, when); timers_check(&timers, "add");
4775 when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
4776 timer = malloc(sizeof(*timer));
4778 timer_add(&timers, timer, when); timers_check(&timers, "add");
4779 when.ts.tv_sec = 0; when.ts.tv_nsec = 291000000;
4780 timer = malloc(sizeof(*timer));
4782 timer_add(&timers, timer, when); timers_check(&timers, "add");
4783 when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000;
4784 timer = malloc(sizeof(*timer));
4786 timer_add(&timers, timer, when); timers_check(&timers, "add");
4787 when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
4788 timer = malloc(sizeof(*timer));
4790 timer_add(&timers, timer, when); timers_check(&timers, "add");
4791 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
4792 timer = malloc(sizeof(*timer));
4794 timer_add(&timers, timer, when); timers_check(&timers, "add");
4795 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4796 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4797 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4798 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4799 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4800 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4801 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4802 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4803 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4804 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4805 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4806 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4807 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4808 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4809 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4810 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4811 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4812 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4813 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4814 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4815 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
4816 timer = malloc(sizeof(*timer));
4818 timer_add(&timers, timer, when); timers_check(&timers, "add");
4819 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
4820 timer = malloc(sizeof(*timer));
4822 timer_add(&timers, timer, when); timers_check(&timers, "add");
4823 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
4824 timer = malloc(sizeof(*timer));
4826 timer_add(&timers, timer, when); timers_check(&timers, "add");
4827 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
4828 timer = malloc(sizeof(*timer));
4830 timer_add(&timers, timer, when); timers_check(&timers, "add");
4831 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4832 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4833 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
4834 timer = malloc(sizeof(*timer));
4836 timer_add(&timers, timer, when); timers_check(&timers, "add");
4837 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
4838 timer = malloc(sizeof(*timer));
4840 timer_add(&timers, timer, when); timers_check(&timers, "add");
4841 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
4842 timer = malloc(sizeof(*timer));
4844 timer_add(&timers, timer, when); timers_check(&timers, "add");
4845 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4846 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4849 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4850 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4851 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4852 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4855 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4856 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4857 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4858 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4859 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4860 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4861 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4862 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4863 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4864 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4865 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4866 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4867 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
4868 timer = malloc(sizeof(*timer));
4870 timer_add(&timers, timer, when); timers_check(&timers, "add");
4871 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
4872 timer = malloc(sizeof(*timer));
4874 timer_add(&timers, timer, when); timers_check(&timers, "add");
4875 when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
4876 timer = malloc(sizeof(*timer));
4878 timer_add(&timers, timer, when); timers_check(&timers, "add");
4879 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
4880 timer = malloc(sizeof(*timer));
4882 timer_add(&timers, timer, when); timers_check(&timers, "add");
4883 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4884 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4885 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4886 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4887 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4888 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4889 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4890 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4891 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4892 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4893 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
4894 timer = malloc(sizeof(*timer));
4896 timer_add(&timers, timer, when); timers_check(&timers, "add");
4897 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
4898 timer = malloc(sizeof(*timer));
4900 timer_add(&timers, timer, when); timers_check(&timers, "add");
4901 when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
4902 timer = malloc(sizeof(*timer));
4904 timer_add(&timers, timer, when); timers_check(&timers, "add");
4905 when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
4906 timer = malloc(sizeof(*timer));
4908 timer_add(&timers, timer, when); timers_check(&timers, "add");
4909 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
4910 timer = malloc(sizeof(*timer));
4912 timer_add(&timers, timer, when); timers_check(&timers, "add");
4913 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4914 timer = malloc(sizeof(*timer));
4916 timer_add(&timers, timer, when); timers_check(&timers, "add");
4917 when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000;
4918 timer = malloc(sizeof(*timer));
4920 timer_add(&timers, timer, when); timers_check(&timers, "add");
4921 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4922 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4923 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4924 timer = malloc(sizeof(*timer));
4926 timer_add(&timers, timer, when); timers_check(&timers, "add");
4927 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4928 timer = malloc(sizeof(*timer));
4930 timer_add(&timers, timer, when); timers_check(&timers, "add");
4931 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
4932 timer = malloc(sizeof(*timer));
4934 timer_add(&timers, timer, when); timers_check(&timers, "add");
4935 when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
4936 timer = malloc(sizeof(*timer));
4938 timer_add(&timers, timer, when); timers_check(&timers, "add");
4939 when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
4940 timer = malloc(sizeof(*timer));
4942 timer_add(&timers, timer, when); timers_check(&timers, "add");
4943 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
4944 timer = malloc(sizeof(*timer));
4946 timer_add(&timers, timer, when); timers_check(&timers, "add");
4947 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4948 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4951 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4952 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4953 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4954 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4955 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4956 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4957 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4958 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4959 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4960 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4961 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4962 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4963 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4964 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4965 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4966 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4967 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
4968 timer = malloc(sizeof(*timer));
4970 timer_add(&timers, timer, when); timers_check(&timers, "add");
4971 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
4972 timer = malloc(sizeof(*timer));
4974 timer_add(&timers, timer, when); timers_check(&timers, "add");
4975 when.ts.tv_sec = 0; when.ts.tv_nsec = 322000000;
4976 timer = malloc(sizeof(*timer));
4978 timer_add(&timers, timer, when); timers_check(&timers, "add");
4979 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
4980 timer = malloc(sizeof(*timer));
4982 timer_add(&timers, timer, when); timers_check(&timers, "add");
4983 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4984 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4985 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4986 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4987 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4988 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4989 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4990 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4991 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4992 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4993 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4994 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4995 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
4996 timer = malloc(sizeof(*timer));
4998 timer_add(&timers, timer, when); timers_check(&timers, "add");
4999 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
5000 timer = malloc(sizeof(*timer));
5002 timer_add(&timers, timer, when); timers_check(&timers, "add");
5003 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5004 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5005 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5006 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5007 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5008 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5009 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5010 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5011 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
5012 timer = malloc(sizeof(*timer));
5014 timer_add(&timers, timer, when); timers_check(&timers, "add");
5015 when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
5016 timer = malloc(sizeof(*timer));
5018 timer_add(&timers, timer, when); timers_check(&timers, "add");
5019 when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
5020 timer = malloc(sizeof(*timer));
5022 timer_add(&timers, timer, when); timers_check(&timers, "add");
5023 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
5024 timer = malloc(sizeof(*timer));
5026 timer_add(&timers, timer, when); timers_check(&timers, "add");
5027 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5028 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5029 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
5030 timer = malloc(sizeof(*timer));
5032 timer_add(&timers, timer, when); timers_check(&timers, "add");
5033 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
5034 timer = malloc(sizeof(*timer));
5036 timer_add(&timers, timer, when); timers_check(&timers, "add");
5037 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
5038 timer = malloc(sizeof(*timer));
5040 timer_add(&timers, timer, when); timers_check(&timers, "add");
5041 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
5042 timer = malloc(sizeof(*timer));
5044 timer_add(&timers, timer, when); timers_check(&timers, "add");
5045 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5046 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5047 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5048 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5049 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5050 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5051 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5052 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5053 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
5054 timer = malloc(sizeof(*timer));
5056 timer_add(&timers, timer, when); timers_check(&timers, "add");
5057 when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
5058 timer = malloc(sizeof(*timer));
5060 timer_add(&timers, timer, when); timers_check(&timers, "add");
5061 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5062 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5063 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5064 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5065 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5066 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5067 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5068 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5069 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5070 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5071 when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
5072 timer = malloc(sizeof(*timer));
5074 timer_add(&timers, timer, when); timers_check(&timers, "add");
5075 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5076 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5077 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5078 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5079 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
5080 timer = malloc(sizeof(*timer));
5082 timer_add(&timers, timer, when); timers_check(&timers, "add");
5083 when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
5084 timer = malloc(sizeof(*timer));
5086 timer_add(&timers, timer, when); timers_check(&timers, "add");
5087 when.ts.tv_sec = 0; when.ts.tv_nsec = 321000000;
5088 timer = malloc(sizeof(*timer));
5090 timer_add(&timers, timer, when); timers_check(&timers, "add");
5091 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5092 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5093 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
5094 timer = malloc(sizeof(*timer));
5096 timer_add(&timers, timer, when); timers_check(&timers, "add");
5097 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
5098 timer = malloc(sizeof(*timer));
5100 timer_add(&timers, timer, when); timers_check(&timers, "add");
5101 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
5102 timer = malloc(sizeof(*timer));
5104 timer_add(&timers, timer, when); timers_check(&timers, "add");
5105 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5106 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5107 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5108 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5109 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5110 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5111 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5112 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5113 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5114 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5115 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5116 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5117 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5118 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5119 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5120 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5121 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5122 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5123 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5124 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5125 when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
5126 timer = malloc(sizeof(*timer));
5128 timer_add(&timers, timer, when); timers_check(&timers, "add");
5129 when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000;
5130 timer = malloc(sizeof(*timer));
5132 timer_add(&timers, timer, when); timers_check(&timers, "add");
5133 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
5134 timer = malloc(sizeof(*timer));
5136 timer_add(&timers, timer, when); timers_check(&timers, "add");
5137 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
5138 timer = malloc(sizeof(*timer));
5140 timer_add(&timers, timer, when); timers_check(&timers, "add");
5141 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5142 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5143 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5144 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5145 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5146 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5147 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5148 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5149 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5150 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5151 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5152 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5153 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5154 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5155 when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000;
5156 timer = malloc(sizeof(*timer));
5158 timer_add(&timers, timer, when); timers_check(&timers, "add");
5159 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
5160 timer = malloc(sizeof(*timer));
5162 timer_add(&timers, timer, when); timers_check(&timers, "add");
5163 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
5164 timer = malloc(sizeof(*timer));
5166 timer_add(&timers, timer, when); timers_check(&timers, "add");
5167 when.ts.tv_sec = 0; when.ts.tv_nsec = 290000000;
5168 timer = malloc(sizeof(*timer));
5170 timer_add(&timers, timer, when); timers_check(&timers, "add");
5171 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
5172 timer = malloc(sizeof(*timer));
5174 timer_add(&timers, timer, when); timers_check(&timers, "add");
5175 when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000;
5176 timer = malloc(sizeof(*timer));
5178 timer_add(&timers, timer, when); timers_check(&timers, "add");
5179 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
5180 timer = malloc(sizeof(*timer));
5182 timer_add(&timers, timer, when); timers_check(&timers, "add");
5183 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5184 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5185 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5186 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5187 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5188 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5189 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5190 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5191 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5192 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5193 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5194 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5195 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
5196 timer = malloc(sizeof(*timer));
5198 timer_add(&timers, timer, when); timers_check(&timers, "add");
5199 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
5200 timer = malloc(sizeof(*timer));
5202 timer_add(&timers, timer, when); timers_check(&timers, "add");
5203 when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000;
5204 timer = malloc(sizeof(*timer));
5206 timer_add(&timers, timer, when); timers_check(&timers, "add");
5207 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5208 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5209 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5210 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5211 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5212 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5213 when.ts.tv_sec = 0; when.ts.tv_nsec = 282000000;
5214 timer = malloc(sizeof(*timer));
5216 timer_add(&timers, timer, when); timers_check(&timers, "add");
5217 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
5218 timer = malloc(sizeof(*timer));
5220 timer_add(&timers, timer, when); timers_check(&timers, "add");
5221 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
5222 timer = malloc(sizeof(*timer));
5224 timer_add(&timers, timer, when); timers_check(&timers, "add");
5225 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
5226 timer = malloc(sizeof(*timer));
5228 timer_add(&timers, timer, when); timers_check(&timers, "add");
5229 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
5230 timer = malloc(sizeof(*timer));
5232 timer_add(&timers, timer, when); timers_check(&timers, "add");
5233 when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000;
5234 timer = malloc(sizeof(*timer));
5236 timer_add(&timers, timer, when); timers_check(&timers, "add");
5237 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
5238 timer = malloc(sizeof(*timer));
5240 timer_add(&timers, timer, when); timers_check(&timers, "add");
5241 when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000;
5242 timer = malloc(sizeof(*timer));
5244 timer_add(&timers, timer, when); timers_check(&timers, "add");
5245 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5246 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5247 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5248 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5249 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5250 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5251 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5252 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5253 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5254 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5255 when.ts.tv_sec = 0; when.ts.tv_nsec = 338000000;
5256 timer = malloc(sizeof(*timer));
5258 timer_add(&timers, timer, when); timers_check(&timers, "add");
5259 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
5260 timer = malloc(sizeof(*timer));
5262 timer_add(&timers, timer, when); timers_check(&timers, "add");
5263 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
5264 timer = malloc(sizeof(*timer));
5266 timer_add(&timers, timer, when); timers_check(&timers, "add");
5267 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
5268 timer = malloc(sizeof(*timer));
5270 timer_add(&timers, timer, when); timers_check(&timers, "add");
5271 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
5272 timer = malloc(sizeof(*timer));
5274 timer_add(&timers, timer, when); timers_check(&timers, "add");
5275 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
5276 timer = malloc(sizeof(*timer));
5278 timer_add(&timers, timer, when); timers_check(&timers, "add");
5279 when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
5280 timer = malloc(sizeof(*timer));
5282 timer_add(&timers, timer, when); timers_check(&timers, "add");
5283 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5284 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5285 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5286 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5287 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5288 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5289 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5290 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5291 when.ts.tv_sec = 0; when.ts.tv_nsec = 300000000;
5292 timer = malloc(sizeof(*timer));
5294 timer_add(&timers, timer, when); timers_check(&timers, "add");
5295 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5296 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5299 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5300 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5301 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5302 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5303 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5304 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5305 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5306 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5307 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5308 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5309 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5310 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5311 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5312 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5313 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5314 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5315 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
5316 timer = malloc(sizeof(*timer));
5318 timer_add(&timers, timer, when); timers_check(&timers, "add");
5319 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
5320 timer = malloc(sizeof(*timer));
5322 timer_add(&timers, timer, when); timers_check(&timers, "add");
5323 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5324 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5325 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5326 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5327 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5328 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5329 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
5330 timer = malloc(sizeof(*timer));
5332 timer_add(&timers, timer, when); timers_check(&timers, "add");
5333 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5334 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5335 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5336 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5337 when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
5338 timer = malloc(sizeof(*timer));
5340 timer_add(&timers, timer, when); timers_check(&timers, "add");
5341 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
5342 timer = malloc(sizeof(*timer));
5344 timer_add(&timers, timer, when); timers_check(&timers, "add");
5345 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
5346 timer = malloc(sizeof(*timer));
5348 timer_add(&timers, timer, when); timers_check(&timers, "add");
5349 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
5350 timer = malloc(sizeof(*timer));
5352 timer_add(&timers, timer, when); timers_check(&timers, "add");
5353 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5354 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5355 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5356 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5357 when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
5358 timer = malloc(sizeof(*timer));
5360 timer_add(&timers, timer, when); timers_check(&timers, "add");
5361 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
5362 timer = malloc(sizeof(*timer));
5364 timer_add(&timers, timer, when); timers_check(&timers, "add");
5365 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
5366 timer = malloc(sizeof(*timer));
5368 timer_add(&timers, timer, when); timers_check(&timers, "add");
5369 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
5370 timer = malloc(sizeof(*timer));
5372 timer_add(&timers, timer, when); timers_check(&timers, "add");
5373 when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000;
5374 timer = malloc(sizeof(*timer));
5376 timer_add(&timers, timer, when); timers_check(&timers, "add");
5377 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5378 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5379 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
5380 timer = malloc(sizeof(*timer));
5382 timer_add(&timers, timer, when); timers_check(&timers, "add");
5383 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
5384 timer = malloc(sizeof(*timer));
5386 timer_add(&timers, timer, when); timers_check(&timers, "add");
5387 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
5388 timer = malloc(sizeof(*timer));
5390 timer_add(&timers, timer, when); timers_check(&timers, "add");
5391 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5392 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5393 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5394 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5395 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5396 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5397 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5398 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5399 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5400 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5401 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
5402 timer = malloc(sizeof(*timer));
5404 timer_add(&timers, timer, when); timers_check(&timers, "add");
5405 when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000;
5406 timer = malloc(sizeof(*timer));
5408 timer_add(&timers, timer, when); timers_check(&timers, "add");
5409 when.ts.tv_sec = 0; when.ts.tv_nsec = 328000000;
5410 timer = malloc(sizeof(*timer));
5412 timer_add(&timers, timer, when); timers_check(&timers, "add");
5413 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5414 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5415 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
5416 timer = malloc(sizeof(*timer));
5418 timer_add(&timers, timer, when); timers_check(&timers, "add");
5419 when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000;
5420 timer = malloc(sizeof(*timer));
5422 timer_add(&timers, timer, when); timers_check(&timers, "add");
5423 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5424 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5425 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5426 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5427 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5428 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5429 when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000;
5430 timer = malloc(sizeof(*timer));
5432 timer_add(&timers, timer, when); timers_check(&timers, "add");
5433 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
5434 timer = malloc(sizeof(*timer));
5436 timer_add(&timers, timer, when); timers_check(&timers, "add");
5437 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
5438 timer = malloc(sizeof(*timer));
5440 timer_add(&timers, timer, when); timers_check(&timers, "add");
5441 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
5442 timer = malloc(sizeof(*timer));
5444 timer_add(&timers, timer, when); timers_check(&timers, "add");
5445 when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000;
5446 timer = malloc(sizeof(*timer));
5448 timer_add(&timers, timer, when); timers_check(&timers, "add");
5449 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
5450 timer = malloc(sizeof(*timer));
5452 timer_add(&timers, timer, when); timers_check(&timers, "add");
5453 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5454 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5455 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5456 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5457 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5458 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5459 when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000;
5460 timer = malloc(sizeof(*timer));
5462 timer_add(&timers, timer, when); timers_check(&timers, "add");
5463 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
5464 timer = malloc(sizeof(*timer));
5466 timer_add(&timers, timer, when); timers_check(&timers, "add");
5467 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5468 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5469 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
5470 timer = malloc(sizeof(*timer));
5472 timer_add(&timers, timer, when); timers_check(&timers, "add");
5473 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5474 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5475 when.ts.tv_sec = 0; when.ts.tv_nsec = 243000000;
5476 timer = malloc(sizeof(*timer));
5478 timer_add(&timers, timer, when); timers_check(&timers, "add");
5479 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
5480 timer = malloc(sizeof(*timer));
5482 timer_add(&timers, timer, when); timers_check(&timers, "add");
5483 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
5484 timer = malloc(sizeof(*timer));
5486 timer_add(&timers, timer, when); timers_check(&timers, "add");
5487 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5488 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5489 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5490 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5491 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5492 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5493 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
5494 timer = malloc(sizeof(*timer));
5496 timer_add(&timers, timer, when); timers_check(&timers, "add");
5497 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5498 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5499 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
5500 timer = malloc(sizeof(*timer));
5502 timer_add(&timers, timer, when); timers_check(&timers, "add");
5503 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
5504 timer = malloc(sizeof(*timer));
5506 timer_add(&timers, timer, when); timers_check(&timers, "add");
5507 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5508 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5511 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5512 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5513 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5514 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5515 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5516 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5517 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5518 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5519 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5520 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5521 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5522 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5523 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5524 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5525 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
5526 timer = malloc(sizeof(*timer));
5528 timer_add(&timers, timer, when); timers_check(&timers, "add");
5529 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
5530 timer = malloc(sizeof(*timer));
5532 timer_add(&timers, timer, when); timers_check(&timers, "add");
5533 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5534 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5535 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5536 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5537 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5538 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5539 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5540 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5541 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
5542 timer = malloc(sizeof(*timer));
5544 timer_add(&timers, timer, when); timers_check(&timers, "add");
5545 when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000;
5546 timer = malloc(sizeof(*timer));
5548 timer_add(&timers, timer, when); timers_check(&timers, "add");
5549 when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
5550 timer = malloc(sizeof(*timer));
5552 timer_add(&timers, timer, when); timers_check(&timers, "add");
5553 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5554 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5555 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5556 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5557 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5558 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5559 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5560 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5561 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5562 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5563 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5564 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5565 when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
5566 timer = malloc(sizeof(*timer));
5568 timer_add(&timers, timer, when); timers_check(&timers, "add");
5569 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5570 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5571 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5572 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5573 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5574 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5575 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5576 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5577 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5578 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5579 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5580 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5581 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5582 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5583 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5584 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5585 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5586 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5587 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5588 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5591 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5592 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5593 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5594 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5595 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5596 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5597 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5598 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5599 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5600 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5601 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5602 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5603 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5604 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5605 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5606 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5607 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5608 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5609 when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
5610 timer = malloc(sizeof(*timer));
5612 timer_add(&timers, timer, when); timers_check(&timers, "add");
5613 when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000;
5614 timer = malloc(sizeof(*timer));
5616 timer_add(&timers, timer, when); timers_check(&timers, "add");
5617 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
5618 timer = malloc(sizeof(*timer));
5620 timer_add(&timers, timer, when); timers_check(&timers, "add");
5621 when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
5622 timer = malloc(sizeof(*timer));
5624 timer_add(&timers, timer, when); timers_check(&timers, "add");
5625 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
5626 timer = malloc(sizeof(*timer));
5628 timer_add(&timers, timer, when); timers_check(&timers, "add");
5629 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
5630 timer = malloc(sizeof(*timer));
5632 timer_add(&timers, timer, when); timers_check(&timers, "add");
5633 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5634 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5635 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5636 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5637 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5638 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5639 when.ts.tv_sec = 0; when.ts.tv_nsec = 323000000;
5640 timer = malloc(sizeof(*timer));
5642 timer_add(&timers, timer, when); timers_check(&timers, "add");
5643 when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000;
5644 timer = malloc(sizeof(*timer));
5646 timer_add(&timers, timer, when); timers_check(&timers, "add");
5647 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
5648 timer = malloc(sizeof(*timer));
5650 timer_add(&timers, timer, when); timers_check(&timers, "add");
5651 when.ts.tv_sec = 0; when.ts.tv_nsec = 320000000;
5652 timer = malloc(sizeof(*timer));
5654 timer_add(&timers, timer, when); timers_check(&timers, "add");
5655 when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000;
5656 timer = malloc(sizeof(*timer));
5658 timer_add(&timers, timer, when); timers_check(&timers, "add");
5659 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5660 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5661 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5662 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5663 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5664 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5665 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5666 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5667 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5668 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5669 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5670 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5671 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5672 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5673 when.ts.tv_sec = 0; when.ts.tv_nsec = 351000000;
5674 timer = malloc(sizeof(*timer));
5676 timer_add(&timers, timer, when); timers_check(&timers, "add");
5677 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
5678 timer = malloc(sizeof(*timer));
5680 timer_add(&timers, timer, when); timers_check(&timers, "add");
5681 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
5682 timer = malloc(sizeof(*timer));
5684 timer_add(&timers, timer, when); timers_check(&timers, "add");
5685 when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000;
5686 timer = malloc(sizeof(*timer));
5688 timer_add(&timers, timer, when); timers_check(&timers, "add");
5689 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
5690 timer = malloc(sizeof(*timer));
5692 timer_add(&timers, timer, when); timers_check(&timers, "add");
5693 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
5694 timer = malloc(sizeof(*timer));
5696 timer_add(&timers, timer, when); timers_check(&timers, "add");
5697 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5698 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5699 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5700 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5701 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5702 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5703 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
5704 timer = malloc(sizeof(*timer));
5706 timer_add(&timers, timer, when); timers_check(&timers, "add");
5707 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
5708 timer = malloc(sizeof(*timer));
5710 timer_add(&timers, timer, when); timers_check(&timers, "add");
5711 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5712 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5713 when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
5714 timer = malloc(sizeof(*timer));
5716 timer_add(&timers, timer, when); timers_check(&timers, "add");
5717 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5718 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5719 when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000;
5720 timer = malloc(sizeof(*timer));
5722 timer_add(&timers, timer, when); timers_check(&timers, "add");
5723 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
5724 timer = malloc(sizeof(*timer));
5726 timer_add(&timers, timer, when); timers_check(&timers, "add");
5727 when.ts.tv_sec = 0; when.ts.tv_nsec = 319000000;
5728 timer = malloc(sizeof(*timer));
5730 timer_add(&timers, timer, when); timers_check(&timers, "add");
5731 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
5732 timer = malloc(sizeof(*timer));
5734 timer_add(&timers, timer, when); timers_check(&timers, "add");
5735 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
5736 timer = malloc(sizeof(*timer));
5738 timer_add(&timers, timer, when); timers_check(&timers, "add");
5739 when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
5740 timer = malloc(sizeof(*timer));
5742 timer_add(&timers, timer, when); timers_check(&timers, "add");
5743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5745 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5746 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5747 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5748 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5749 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
5750 timer = malloc(sizeof(*timer));
5752 timer_add(&timers, timer, when); timers_check(&timers, "add");
5753 when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000;
5754 timer = malloc(sizeof(*timer));
5756 timer_add(&timers, timer, when); timers_check(&timers, "add");
5757 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5758 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5759 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5760 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5761 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5762 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5763 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5764 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5765 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5766 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5767 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5768 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5769 when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
5770 timer = malloc(sizeof(*timer));
5772 timer_add(&timers, timer, when); timers_check(&timers, "add");
5773 when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
5774 timer = malloc(sizeof(*timer));
5776 timer_add(&timers, timer, when); timers_check(&timers, "add");
5777 when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000;
5778 timer = malloc(sizeof(*timer));
5780 timer_add(&timers, timer, when); timers_check(&timers, "add");
5781 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
5782 timer = malloc(sizeof(*timer));
5784 timer_add(&timers, timer, when); timers_check(&timers, "add");
5785 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5786 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5787 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5788 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5789 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
5790 timer = malloc(sizeof(*timer));
5792 timer_add(&timers, timer, when); timers_check(&timers, "add");
5793 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
5794 timer = malloc(sizeof(*timer));
5796 timer_add(&timers, timer, when); timers_check(&timers, "add");
5797 when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
5798 timer = malloc(sizeof(*timer));
5800 timer_add(&timers, timer, when); timers_check(&timers, "add");
5801 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5802 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5803 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5804 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5805 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5806 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5807 when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
5808 timer = malloc(sizeof(*timer));
5810 timer_add(&timers, timer, when); timers_check(&timers, "add");
5811 when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
5812 timer = malloc(sizeof(*timer));
5814 timer_add(&timers, timer, when); timers_check(&timers, "add");
5815 when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
5816 timer = malloc(sizeof(*timer));
5818 timer_add(&timers, timer, when); timers_check(&timers, "add");
5819 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
5820 timer = malloc(sizeof(*timer));
5822 timer_add(&timers, timer, when); timers_check(&timers, "add");
5823 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5824 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5825 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5826 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5827 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5828 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5829 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5830 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5831 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5832 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5833 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5834 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5835 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5836 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5837 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5838 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5839 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5840 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5841 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5842 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5843 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5844 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5845 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5846 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5849 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5850 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5851 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5852 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5855 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5856 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5857 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5858 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5859 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5860 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5861 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5862 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5863 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5864 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5865 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5866 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5867 when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
5868 timer = malloc(sizeof(*timer));
5870 timer_add(&timers, timer, when); timers_check(&timers, "add");
5871 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
5872 timer = malloc(sizeof(*timer));
5874 timer_add(&timers, timer, when); timers_check(&timers, "add");
5875 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
5876 timer = malloc(sizeof(*timer));
5878 timer_add(&timers, timer, when); timers_check(&timers, "add");
5879 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5880 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5881 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5882 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5883 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
5884 timer = malloc(sizeof(*timer));
5886 timer_add(&timers, timer, when); timers_check(&timers, "add");
5887 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5888 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5889 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
5890 timer = malloc(sizeof(*timer));
5892 timer_add(&timers, timer, when); timers_check(&timers, "add");
5893 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
5894 timer = malloc(sizeof(*timer));
5896 timer_add(&timers, timer, when); timers_check(&timers, "add");
5897 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
5898 timer = malloc(sizeof(*timer));
5900 timer_add(&timers, timer, when); timers_check(&timers, "add");
5901 when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000;
5902 timer = malloc(sizeof(*timer));
5904 timer_add(&timers, timer, when); timers_check(&timers, "add");
5905 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
5906 timer = malloc(sizeof(*timer));
5908 timer_add(&timers, timer, when); timers_check(&timers, "add");
5909 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
5910 timer = malloc(sizeof(*timer));
5912 timer_add(&timers, timer, when); timers_check(&timers, "add");
5913 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5914 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5915 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
5916 timer = malloc(sizeof(*timer));
5918 timer_add(&timers, timer, when); timers_check(&timers, "add");
5919 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
5920 timer = malloc(sizeof(*timer));
5922 timer_add(&timers, timer, when); timers_check(&timers, "add");
5923 when.ts.tv_sec = 0; when.ts.tv_nsec = 360000000;
5924 timer = malloc(sizeof(*timer));
5926 timer_add(&timers, timer, when); timers_check(&timers, "add");
5927 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5928 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5929 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
5930 timer = malloc(sizeof(*timer));
5932 timer_add(&timers, timer, when); timers_check(&timers, "add");
5933 when.ts.tv_sec = 0; when.ts.tv_nsec = 349000000;
5934 timer = malloc(sizeof(*timer));
5936 timer_add(&timers, timer, when); timers_check(&timers, "add");
5937 when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
5938 timer = malloc(sizeof(*timer));
5940 timer_add(&timers, timer, when); timers_check(&timers, "add");
5941 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
5942 timer = malloc(sizeof(*timer));
5944 timer_add(&timers, timer, when); timers_check(&timers, "add");
5945 when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000;
5946 timer = malloc(sizeof(*timer));
5948 timer_add(&timers, timer, when); timers_check(&timers, "add");
5949 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
5950 timer = malloc(sizeof(*timer));
5952 timer_add(&timers, timer, when); timers_check(&timers, "add");
5953 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5954 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5955 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5956 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5957 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5958 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5959 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
5960 timer = malloc(sizeof(*timer));
5962 timer_add(&timers, timer, when); timers_check(&timers, "add");
5963 when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000;
5964 timer = malloc(sizeof(*timer));
5966 timer_add(&timers, timer, when); timers_check(&timers, "add");
5967 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5968 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5969 when.ts.tv_sec = 0; when.ts.tv_nsec = 327000000;
5970 timer = malloc(sizeof(*timer));
5972 timer_add(&timers, timer, when); timers_check(&timers, "add");
5973 when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000;
5974 timer = malloc(sizeof(*timer));
5976 timer_add(&timers, timer, when); timers_check(&timers, "add");
5977 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
5978 timer = malloc(sizeof(*timer));
5980 timer_add(&timers, timer, when); timers_check(&timers, "add");
5981 when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
5982 timer = malloc(sizeof(*timer));
5984 timer_add(&timers, timer, when); timers_check(&timers, "add");
5985 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5986 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5987 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5988 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5989 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5990 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5991 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5992 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5993 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5994 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5995 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5996 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5997 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
5998 timer = malloc(sizeof(*timer));
6000 timer_add(&timers, timer, when); timers_check(&timers, "add");
6001 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
6002 timer = malloc(sizeof(*timer));
6004 timer_add(&timers, timer, when); timers_check(&timers, "add");
6005 when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000;
6006 timer = malloc(sizeof(*timer));
6008 timer_add(&timers, timer, when); timers_check(&timers, "add");
6009 when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000;
6010 timer = malloc(sizeof(*timer));
6012 timer_add(&timers, timer, when); timers_check(&timers, "add");
6013 when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000;
6014 timer = malloc(sizeof(*timer));
6016 timer_add(&timers, timer, when); timers_check(&timers, "add");
6017 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6018 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6019 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6020 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6021 when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
6022 timer = malloc(sizeof(*timer));
6024 timer_add(&timers, timer, when); timers_check(&timers, "add");
6025 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6026 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6027 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6028 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6029 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6030 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6031 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
6032 timer = malloc(sizeof(*timer));
6034 timer_add(&timers, timer, when); timers_check(&timers, "add");
6035 when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000;
6036 timer = malloc(sizeof(*timer));
6038 timer_add(&timers, timer, when); timers_check(&timers, "add");
6039 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6040 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6041 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
6042 timer = malloc(sizeof(*timer));
6044 timer_add(&timers, timer, when); timers_check(&timers, "add");
6045 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6046 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6047 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6048 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6049 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6050 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6051 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6052 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6053 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6054 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6055 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6056 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6057 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6058 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6059 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6060 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6061 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6062 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6063 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6064 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6065 when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
6066 timer = malloc(sizeof(*timer));
6068 timer_add(&timers, timer, when); timers_check(&timers, "add");
6069 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
6070 timer = malloc(sizeof(*timer));
6072 timer_add(&timers, timer, when); timers_check(&timers, "add");
6073 when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000;
6074 timer = malloc(sizeof(*timer));
6076 timer_add(&timers, timer, when); timers_check(&timers, "add");
6077 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
6078 timer = malloc(sizeof(*timer));
6080 timer_add(&timers, timer, when); timers_check(&timers, "add");
6081 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6082 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6083 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6084 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6085 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6086 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6087 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6088 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6089 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6090 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6091 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6092 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6093 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6094 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6095 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6096 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6097 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6098 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6099 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6100 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6101 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6102 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6103 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6104 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6105 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6106 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6107 when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000;
6108 timer = malloc(sizeof(*timer));
6110 timer_add(&timers, timer, when); timers_check(&timers, "add");
6111 when.ts.tv_sec = 0; when.ts.tv_nsec = 314000000;
6112 timer = malloc(sizeof(*timer));
6114 timer_add(&timers, timer, when); timers_check(&timers, "add");
6115 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
6116 timer = malloc(sizeof(*timer));
6118 timer_add(&timers, timer, when); timers_check(&timers, "add");
6119 when.ts.tv_sec = 0; when.ts.tv_nsec = 368000000;
6120 timer = malloc(sizeof(*timer));
6122 timer_add(&timers, timer, when); timers_check(&timers, "add");
6123 when.ts.tv_sec = 0; when.ts.tv_nsec = 335000000;
6124 timer = malloc(sizeof(*timer));
6126 timer_add(&timers, timer, when); timers_check(&timers, "add");
6127 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
6128 timer = malloc(sizeof(*timer));
6130 timer_add(&timers, timer, when); timers_check(&timers, "add");
6131 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6132 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6133 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
6134 timer = malloc(sizeof(*timer));
6136 timer_add(&timers, timer, when); timers_check(&timers, "add");
6137 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6138 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6139 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6140 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6141 when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
6142 timer = malloc(sizeof(*timer));
6144 timer_add(&timers, timer, when); timers_check(&timers, "add");
6145 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6146 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6147 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6148 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6149 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6150 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6151 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6152 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6153 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
6154 timer = malloc(sizeof(*timer));
6156 timer_add(&timers, timer, when); timers_check(&timers, "add");
6157 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
6158 timer = malloc(sizeof(*timer));
6160 timer_add(&timers, timer, when); timers_check(&timers, "add");
6161 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
6162 timer = malloc(sizeof(*timer));
6164 timer_add(&timers, timer, when); timers_check(&timers, "add");
6165 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
6166 timer = malloc(sizeof(*timer));
6168 timer_add(&timers, timer, when); timers_check(&timers, "add");
6169 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
6170 timer = malloc(sizeof(*timer));
6172 timer_add(&timers, timer, when); timers_check(&timers, "add");
6173 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6174 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6176 while (timer_earliest(&timers, &when)) {
6177 free(timers_expire(&timers, when));
6180 ok1(timers_check(&timers, NULL));
6181 timers_cleanup(&timers);
6183 return exit_status();