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>
6
7 /* This is the original pre-cut-down dump. */
main(void)8 int main(void)
9 {
10 struct timemono when;
11 struct timers timers;
12 struct timer *timer;
13
14 plan_tests(2);
15
16 when.ts.tv_sec = 0; when.ts.tv_nsec = 0;
17 timers_init(&timers, when);
18
19 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
20 timer = malloc(sizeof(*timer));
21 timer_init(timer);
22 timer_addmono(&timers, timer, when);
23 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
24 timer = malloc(sizeof(*timer));
25 timer_init(timer);
26 timer_addmono(&timers, timer, when);
27 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
28 timer = malloc(sizeof(*timer));
29 timer_init(timer);
30 timer_addmono(&timers, timer, when);
31 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
32 timer = malloc(sizeof(*timer));
33 timer_init(timer);
34 timer_addmono(&timers, timer, when);
35 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
36 timer = malloc(sizeof(*timer));
37 timer_init(timer);
38 timer_addmono(&timers, timer, when);
39 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
40 timer = malloc(sizeof(*timer));
41 timer_init(timer);
42 timer_addmono(&timers, timer, when);
43 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
44 timer = malloc(sizeof(*timer));
45 timer_init(timer);
46 timer_addmono(&timers, timer, when);
47 when.ts.tv_sec = 0; when.ts.tv_nsec = 18000000;
48 timer = malloc(sizeof(*timer));
49 timer_init(timer);
50 timer_addmono(&timers, timer, when);
51 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
52 timer = malloc(sizeof(*timer));
53 timer_init(timer);
54 timer_addmono(&timers, timer, when);
55 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
56 timer = malloc(sizeof(*timer));
57 timer_init(timer);
58 timer_addmono(&timers, timer, when);
59 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
60 timer = malloc(sizeof(*timer));
61 timer_init(timer);
62 timer_addmono(&timers, timer, when);
63 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
64 timer = malloc(sizeof(*timer));
65 timer_init(timer);
66 timer_addmono(&timers, timer, when);
67 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
68 timer = malloc(sizeof(*timer));
69 timer_init(timer);
70 timer_addmono(&timers, timer, when);
71 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
72 timer = malloc(sizeof(*timer));
73 timer_init(timer);
74 timer_addmono(&timers, timer, when);
75 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
76 timer = malloc(sizeof(*timer));
77 timer_init(timer);
78 timer_addmono(&timers, timer, when);
79 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
80 timer = malloc(sizeof(*timer));
81 timer_init(timer);
82 timer_addmono(&timers, timer, when);
83 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
84 timer = malloc(sizeof(*timer));
85 timer_init(timer);
86 timer_addmono(&timers, timer, when);
87 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
88 timer = malloc(sizeof(*timer));
89 timer_init(timer);
90 timer_addmono(&timers, timer, when);
91 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
92 timer = malloc(sizeof(*timer));
93 timer_init(timer);
94 timer_addmono(&timers, timer, when);
95 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
96 timer = malloc(sizeof(*timer));
97 timer_init(timer);
98 timer_addmono(&timers, timer, when);
99 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
100 timer = malloc(sizeof(*timer));
101 timer_init(timer);
102 timer_addmono(&timers, timer, when);
103 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
104 timer = malloc(sizeof(*timer));
105 timer_init(timer);
106 timer_addmono(&timers, timer, when);
107 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
108 timer = malloc(sizeof(*timer));
109 timer_init(timer);
110 timer_addmono(&timers, timer, when);
111 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
112 timer = malloc(sizeof(*timer));
113 timer_init(timer);
114 timer_addmono(&timers, timer, when);
115 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
116 timer = malloc(sizeof(*timer));
117 timer_init(timer);
118 timer_addmono(&timers, timer, when);
119 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
120 timer = malloc(sizeof(*timer));
121 timer_init(timer);
122 timer_addmono(&timers, timer, when);
123 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
124 timer = malloc(sizeof(*timer));
125 timer_init(timer);
126 timer_addmono(&timers, timer, when);
127 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
128 timer = malloc(sizeof(*timer));
129 timer_init(timer);
130 timer_addmono(&timers, timer, when);
131 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
132 timer = malloc(sizeof(*timer));
133 timer_init(timer);
134 timer_addmono(&timers, timer, when);
135 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
136 timer = malloc(sizeof(*timer));
137 timer_init(timer);
138 timer_addmono(&timers, timer, when);
139 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
140 timer = malloc(sizeof(*timer));
141 timer_init(timer);
142 timer_addmono(&timers, timer, when);
143 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
144 timer = malloc(sizeof(*timer));
145 timer_init(timer);
146 timer_addmono(&timers, timer, when);
147 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
148 timer = malloc(sizeof(*timer));
149 timer_init(timer);
150 timer_addmono(&timers, timer, when);
151 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
152 timer = malloc(sizeof(*timer));
153 timer_init(timer);
154 timer_addmono(&timers, timer, when);
155 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
156 timer = malloc(sizeof(*timer));
157 timer_init(timer);
158 timer_addmono(&timers, timer, when);
159 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
160 timer = malloc(sizeof(*timer));
161 timer_init(timer);
162 timer_addmono(&timers, timer, when);
163 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
164 timer = malloc(sizeof(*timer));
165 timer_init(timer);
166 timer_addmono(&timers, timer, when);
167 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
168 timer = malloc(sizeof(*timer));
169 timer_init(timer);
170 timer_addmono(&timers, timer, when);
171 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
172 timer = malloc(sizeof(*timer));
173 timer_init(timer);
174 timer_addmono(&timers, timer, when);
175 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
176 timer = malloc(sizeof(*timer));
177 timer_init(timer);
178 timer_addmono(&timers, timer, when);
179 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
180 timer = malloc(sizeof(*timer));
181 timer_init(timer);
182 timer_addmono(&timers, timer, when);
183 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
184 timer = malloc(sizeof(*timer));
185 timer_init(timer);
186 timer_addmono(&timers, timer, when);
187 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
188 timer = malloc(sizeof(*timer));
189 timer_init(timer);
190 timer_addmono(&timers, timer, when);
191 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
192 timer = malloc(sizeof(*timer));
193 timer_init(timer);
194 timer_addmono(&timers, timer, when);
195 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
196 timer = malloc(sizeof(*timer));
197 timer_init(timer);
198 timer_addmono(&timers, timer, when);
199 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
200 timer = malloc(sizeof(*timer));
201 timer_init(timer);
202 timer_addmono(&timers, timer, when);
203 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
204 timer = malloc(sizeof(*timer));
205 timer_init(timer);
206 timer_addmono(&timers, timer, when);
207 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
208 timer = malloc(sizeof(*timer));
209 timer_init(timer);
210 timer_addmono(&timers, timer, when);
211 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
212 timer = malloc(sizeof(*timer));
213 timer_init(timer);
214 timer_addmono(&timers, timer, when);
215 when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
216 timer = malloc(sizeof(*timer));
217 timer_init(timer);
218 timer_addmono(&timers, timer, when);
219 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
220 timer = malloc(sizeof(*timer));
221 timer_init(timer);
222 timer_addmono(&timers, timer, when);
223 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
224 timer = malloc(sizeof(*timer));
225 timer_init(timer);
226 timer_addmono(&timers, timer, when);
227 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
228 timer = malloc(sizeof(*timer));
229 timer_init(timer);
230 timer_addmono(&timers, timer, when);
231 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
232 timer = malloc(sizeof(*timer));
233 timer_init(timer);
234 timer_addmono(&timers, timer, when);
235 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
236 timer = malloc(sizeof(*timer));
237 timer_init(timer);
238 timer_addmono(&timers, timer, when);
239 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
240 timer = malloc(sizeof(*timer));
241 timer_init(timer);
242 timer_addmono(&timers, timer, when);
243 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
244 timer = malloc(sizeof(*timer));
245 timer_init(timer);
246 timer_addmono(&timers, timer, when);
247 when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
248 timer = malloc(sizeof(*timer));
249 timer_init(timer);
250 timer_addmono(&timers, timer, when);
251 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
252 timer = malloc(sizeof(*timer));
253 timer_init(timer);
254 timer_addmono(&timers, timer, when);
255 when.ts.tv_sec = 0; when.ts.tv_nsec = 13000000;
256 timer = malloc(sizeof(*timer));
257 timer_init(timer);
258 timer_addmono(&timers, timer, when);
259 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
260 timer = malloc(sizeof(*timer));
261 timer_init(timer);
262 timer_addmono(&timers, timer, when);
263 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
264 timer = malloc(sizeof(*timer));
265 timer_init(timer);
266 timer_addmono(&timers, timer, when);
267 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
268 timer = malloc(sizeof(*timer));
269 timer_init(timer);
270 timer_addmono(&timers, timer, when);
271 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
272 timer = malloc(sizeof(*timer));
273 timer_init(timer);
274 timer_addmono(&timers, timer, when);
275 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
276 timer = malloc(sizeof(*timer));
277 timer_init(timer);
278 timer_addmono(&timers, timer, when);
279 when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
280 timer = malloc(sizeof(*timer));
281 timer_init(timer);
282 timer_addmono(&timers, timer, when);
283 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
284 timer = malloc(sizeof(*timer));
285 timer_init(timer);
286 timer_addmono(&timers, timer, when);
287 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
288 timer = malloc(sizeof(*timer));
289 timer_init(timer);
290 timer_addmono(&timers, timer, when);
291 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
292 timer = malloc(sizeof(*timer));
293 timer_init(timer);
294 timer_addmono(&timers, timer, when);
295 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
296 timer = malloc(sizeof(*timer));
297 timer_init(timer);
298 timer_addmono(&timers, timer, when);
299 when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
300 timer = malloc(sizeof(*timer));
301 timer_init(timer);
302 timer_addmono(&timers, timer, when);
303 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
304 timer = malloc(sizeof(*timer));
305 timer_init(timer);
306 timer_addmono(&timers, timer, when);
307 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
308 timer = malloc(sizeof(*timer));
309 timer_init(timer);
310 timer_addmono(&timers, timer, when);
311 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
312 timer = malloc(sizeof(*timer));
313 timer_init(timer);
314 timer_addmono(&timers, timer, when);
315 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
316 timer = malloc(sizeof(*timer));
317 timer_init(timer);
318 timer_addmono(&timers, timer, when);
319 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
320 timer = malloc(sizeof(*timer));
321 timer_init(timer);
322 timer_addmono(&timers, timer, when);
323 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
324 timer = malloc(sizeof(*timer));
325 timer_init(timer);
326 timer_addmono(&timers, timer, when);
327 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
328 timer = malloc(sizeof(*timer));
329 timer_init(timer);
330 timer_addmono(&timers, timer, when);
331 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
332 timer = malloc(sizeof(*timer));
333 timer_init(timer);
334 timer_addmono(&timers, timer, when);
335 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
336 timer = malloc(sizeof(*timer));
337 timer_init(timer);
338 timer_addmono(&timers, timer, when);
339 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
340 timer = malloc(sizeof(*timer));
341 timer_init(timer);
342 timer_addmono(&timers, timer, when);
343 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
344 timer = malloc(sizeof(*timer));
345 timer_init(timer);
346 timer_addmono(&timers, timer, when);
347 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
348 timer = malloc(sizeof(*timer));
349 timer_init(timer);
350 timer_addmono(&timers, timer, when);
351 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
352 timer = malloc(sizeof(*timer));
353 timer_init(timer);
354 timer_addmono(&timers, timer, when);
355 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
356 timer = malloc(sizeof(*timer));
357 timer_init(timer);
358 timer_addmono(&timers, timer, when);
359 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
360 timer = malloc(sizeof(*timer));
361 timer_init(timer);
362 timer_addmono(&timers, timer, when);
363 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
364 timer = malloc(sizeof(*timer));
365 timer_init(timer);
366 timer_addmono(&timers, timer, when);
367 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
368 timer = malloc(sizeof(*timer));
369 timer_init(timer);
370 timer_addmono(&timers, timer, when);
371 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
372 timer = malloc(sizeof(*timer));
373 timer_init(timer);
374 timer_addmono(&timers, timer, when);
375 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
376 timer = malloc(sizeof(*timer));
377 timer_init(timer);
378 timer_addmono(&timers, timer, when);
379 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
380 timer = malloc(sizeof(*timer));
381 timer_init(timer);
382 timer_addmono(&timers, timer, when);
383 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
384 timer = malloc(sizeof(*timer));
385 timer_init(timer);
386 timer_addmono(&timers, timer, when);
387 when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000;
388 timer = malloc(sizeof(*timer));
389 timer_init(timer);
390 timer_addmono(&timers, timer, when);
391 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
392 timer = malloc(sizeof(*timer));
393 timer_init(timer);
394 timer_addmono(&timers, timer, when);
395 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
396 timer = malloc(sizeof(*timer));
397 timer_init(timer);
398 timer_addmono(&timers, timer, when);
399 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
400 timer = malloc(sizeof(*timer));
401 timer_init(timer);
402 timer_addmono(&timers, timer, when);
403 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
404 timer = malloc(sizeof(*timer));
405 timer_init(timer);
406 timer_addmono(&timers, timer, when);
407 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
408 timer = malloc(sizeof(*timer));
409 timer_init(timer);
410 timer_addmono(&timers, timer, when);
411 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
412 timer = malloc(sizeof(*timer));
413 timer_init(timer);
414 timer_addmono(&timers, timer, when);
415 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
416 timer = malloc(sizeof(*timer));
417 timer_init(timer);
418 timer_addmono(&timers, timer, when);
419 when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
420 timer = malloc(sizeof(*timer));
421 timer_init(timer);
422 timer_addmono(&timers, timer, when);
423 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
424 timer = malloc(sizeof(*timer));
425 timer_init(timer);
426 timer_addmono(&timers, timer, when);
427 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
428 timer = malloc(sizeof(*timer));
429 timer_init(timer);
430 timer_addmono(&timers, timer, when);
431 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
432 timer = malloc(sizeof(*timer));
433 timer_init(timer);
434 timer_addmono(&timers, timer, when);
435 when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000;
436 timer = malloc(sizeof(*timer));
437 timer_init(timer);
438 timer_addmono(&timers, timer, when);
439 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
440 timer = malloc(sizeof(*timer));
441 timer_init(timer);
442 timer_addmono(&timers, timer, when);
443 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
444 timer = malloc(sizeof(*timer));
445 timer_init(timer);
446 timer_addmono(&timers, timer, when);
447 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
448 timer = malloc(sizeof(*timer));
449 timer_init(timer);
450 timer_addmono(&timers, timer, when);
451 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
452 timer = malloc(sizeof(*timer));
453 timer_init(timer);
454 timer_addmono(&timers, timer, when);
455 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
456 timer = malloc(sizeof(*timer));
457 timer_init(timer);
458 timer_addmono(&timers, timer, when);
459 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
460 timer = malloc(sizeof(*timer));
461 timer_init(timer);
462 timer_addmono(&timers, timer, when);
463 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
464 timer = malloc(sizeof(*timer));
465 timer_init(timer);
466 timer_addmono(&timers, timer, when);
467 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
468 timer = malloc(sizeof(*timer));
469 timer_init(timer);
470 timer_addmono(&timers, timer, when);
471 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
472 timer = malloc(sizeof(*timer));
473 timer_init(timer);
474 timer_addmono(&timers, timer, when);
475 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
476 timer = malloc(sizeof(*timer));
477 timer_init(timer);
478 timer_addmono(&timers, timer, when);
479 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
480 timer = malloc(sizeof(*timer));
481 timer_init(timer);
482 timer_addmono(&timers, timer, when);
483 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
484 timer = malloc(sizeof(*timer));
485 timer_init(timer);
486 timer_addmono(&timers, timer, when);
487 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
488 timer = malloc(sizeof(*timer));
489 timer_init(timer);
490 timer_addmono(&timers, timer, when);
491 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
492 timer = malloc(sizeof(*timer));
493 timer_init(timer);
494 timer_addmono(&timers, timer, when);
495 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
496 timer = malloc(sizeof(*timer));
497 timer_init(timer);
498 timer_addmono(&timers, timer, when);
499 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
500 timer = malloc(sizeof(*timer));
501 timer_init(timer);
502 timer_addmono(&timers, timer, when);
503 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
504 timer = malloc(sizeof(*timer));
505 timer_init(timer);
506 timer_addmono(&timers, timer, when);
507 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
508 timer = malloc(sizeof(*timer));
509 timer_init(timer);
510 timer_addmono(&timers, timer, when);
511 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
512 timer = malloc(sizeof(*timer));
513 timer_init(timer);
514 timer_addmono(&timers, timer, when);
515 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
516 timer = malloc(sizeof(*timer));
517 timer_init(timer);
518 timer_addmono(&timers, timer, when);
519 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
520 timer = malloc(sizeof(*timer));
521 timer_init(timer);
522 timer_addmono(&timers, timer, when);
523 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
524 timer = malloc(sizeof(*timer));
525 timer_init(timer);
526 timer_addmono(&timers, timer, when);
527 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
528 timer = malloc(sizeof(*timer));
529 timer_init(timer);
530 timer_addmono(&timers, timer, when);
531 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
532 timer = malloc(sizeof(*timer));
533 timer_init(timer);
534 timer_addmono(&timers, timer, when);
535 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
536 timer = malloc(sizeof(*timer));
537 timer_init(timer);
538 timer_addmono(&timers, timer, when);
539 when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
540 timer = malloc(sizeof(*timer));
541 timer_init(timer);
542 timer_addmono(&timers, timer, when);
543 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
544 timer = malloc(sizeof(*timer));
545 timer_init(timer);
546 timer_addmono(&timers, timer, when);
547 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
548 timer = malloc(sizeof(*timer));
549 timer_init(timer);
550 timer_addmono(&timers, timer, when);
551 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
552 timer = malloc(sizeof(*timer));
553 timer_init(timer);
554 timer_addmono(&timers, timer, when);
555 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
556 timer = malloc(sizeof(*timer));
557 timer_init(timer);
558 timer_addmono(&timers, timer, when);
559 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
560 timer = malloc(sizeof(*timer));
561 timer_init(timer);
562 timer_addmono(&timers, timer, when);
563 when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
564 timer = malloc(sizeof(*timer));
565 timer_init(timer);
566 timer_addmono(&timers, timer, when);
567 when.ts.tv_sec = 0; when.ts.tv_nsec = 90000000;
568 timer = malloc(sizeof(*timer));
569 timer_init(timer);
570 timer_addmono(&timers, timer, when);
571 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
572 timer = malloc(sizeof(*timer));
573 timer_init(timer);
574 timer_addmono(&timers, timer, when);
575 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
576 timer = malloc(sizeof(*timer));
577 timer_init(timer);
578 timer_addmono(&timers, timer, when);
579 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
580 timer = malloc(sizeof(*timer));
581 timer_init(timer);
582 timer_addmono(&timers, timer, when);
583 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
584 timer = malloc(sizeof(*timer));
585 timer_init(timer);
586 timer_addmono(&timers, timer, when);
587 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
588 timer = malloc(sizeof(*timer));
589 timer_init(timer);
590 timer_addmono(&timers, timer, when);
591 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
592 timer = malloc(sizeof(*timer));
593 timer_init(timer);
594 timer_addmono(&timers, timer, when);
595 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
596 timer = malloc(sizeof(*timer));
597 timer_init(timer);
598 timer_addmono(&timers, timer, when);
599 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
600 timer = malloc(sizeof(*timer));
601 timer_init(timer);
602 timer_addmono(&timers, timer, when);
603 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
604 timer = malloc(sizeof(*timer));
605 timer_init(timer);
606 timer_addmono(&timers, timer, when);
607 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
608 timer = malloc(sizeof(*timer));
609 timer_init(timer);
610 timer_addmono(&timers, timer, when);
611 when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
612 timer = malloc(sizeof(*timer));
613 timer_init(timer);
614 timer_addmono(&timers, timer, when);
615 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
616 timer = malloc(sizeof(*timer));
617 timer_init(timer);
618 timer_addmono(&timers, timer, when);
619 when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000;
620 timer = malloc(sizeof(*timer));
621 timer_init(timer);
622 timer_addmono(&timers, timer, when);
623 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
624 timer = malloc(sizeof(*timer));
625 timer_init(timer);
626 timer_addmono(&timers, timer, when);
627 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
628 timer = malloc(sizeof(*timer));
629 timer_init(timer);
630 timer_addmono(&timers, timer, when);
631 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
632 timer = malloc(sizeof(*timer));
633 timer_init(timer);
634 timer_addmono(&timers, timer, when);
635 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
636 timer = malloc(sizeof(*timer));
637 timer_init(timer);
638 timer_addmono(&timers, timer, when);
639 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
640 timer = malloc(sizeof(*timer));
641 timer_init(timer);
642 timer_addmono(&timers, timer, when);
643 when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
644 timer = malloc(sizeof(*timer));
645 timer_init(timer);
646 timer_addmono(&timers, timer, when);
647 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
648 timer = malloc(sizeof(*timer));
649 timer_init(timer);
650 timer_addmono(&timers, timer, when);
651 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
652 timer = malloc(sizeof(*timer));
653 timer_init(timer);
654 timer_addmono(&timers, timer, when);
655 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
656 timer = malloc(sizeof(*timer));
657 timer_init(timer);
658 timer_addmono(&timers, timer, when);
659 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
660 timer = malloc(sizeof(*timer));
661 timer_init(timer);
662 timer_addmono(&timers, timer, when);
663 when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
664 timer = malloc(sizeof(*timer));
665 timer_init(timer);
666 timer_addmono(&timers, timer, when);
667 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
668 timer = malloc(sizeof(*timer));
669 timer_init(timer);
670 timer_addmono(&timers, timer, when);
671 when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
672 timer = malloc(sizeof(*timer));
673 timer_init(timer);
674 timer_addmono(&timers, timer, when);
675 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
676 timer = malloc(sizeof(*timer));
677 timer_init(timer);
678 timer_addmono(&timers, timer, when);
679 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
680 timer = malloc(sizeof(*timer));
681 timer_init(timer);
682 timer_addmono(&timers, timer, when);
683 when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
684 timer = malloc(sizeof(*timer));
685 timer_init(timer);
686 timer_addmono(&timers, timer, when);
687 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
688 timer = malloc(sizeof(*timer));
689 timer_init(timer);
690 timer_addmono(&timers, timer, when);
691 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
692 timer = malloc(sizeof(*timer));
693 timer_init(timer);
694 timer_addmono(&timers, timer, when);
695 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
696 timer = malloc(sizeof(*timer));
697 timer_init(timer);
698 timer_addmono(&timers, timer, when);
699 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
700 timer = malloc(sizeof(*timer));
701 timer_init(timer);
702 timer_addmono(&timers, timer, when);
703 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
704 timer = malloc(sizeof(*timer));
705 timer_init(timer);
706 timer_addmono(&timers, timer, when);
707 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
708 timer = malloc(sizeof(*timer));
709 timer_init(timer);
710 timer_addmono(&timers, timer, when);
711 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
712 timer = malloc(sizeof(*timer));
713 timer_init(timer);
714 timer_addmono(&timers, timer, when);
715 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
716 timer = malloc(sizeof(*timer));
717 timer_init(timer);
718 timer_addmono(&timers, timer, when);
719 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
720 timer = malloc(sizeof(*timer));
721 timer_init(timer);
722 timer_addmono(&timers, timer, when);
723 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
724 timer = malloc(sizeof(*timer));
725 timer_init(timer);
726 timer_addmono(&timers, timer, when);
727 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
728 timer = malloc(sizeof(*timer));
729 timer_init(timer);
730 timer_addmono(&timers, timer, when);
731 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
732 timer = malloc(sizeof(*timer));
733 timer_init(timer);
734 timer_addmono(&timers, timer, when);
735 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
736 timer = malloc(sizeof(*timer));
737 timer_init(timer);
738 timer_addmono(&timers, timer, when);
739 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
740 timer = malloc(sizeof(*timer));
741 timer_init(timer);
742 timer_addmono(&timers, timer, when);
743 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
744 timer = malloc(sizeof(*timer));
745 timer_init(timer);
746 timer_addmono(&timers, timer, when);
747 when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
748 timer = malloc(sizeof(*timer));
749 timer_init(timer);
750 timer_addmono(&timers, timer, when);
751 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
752 timer = malloc(sizeof(*timer));
753 timer_init(timer);
754 timer_addmono(&timers, timer, when);
755 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
756 timer = malloc(sizeof(*timer));
757 timer_init(timer);
758 timer_addmono(&timers, timer, when);
759 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
760 timer = malloc(sizeof(*timer));
761 timer_init(timer);
762 timer_addmono(&timers, timer, when);
763 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
764 timer = malloc(sizeof(*timer));
765 timer_init(timer);
766 timer_addmono(&timers, timer, when);
767 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
768 timer = malloc(sizeof(*timer));
769 timer_init(timer);
770 timer_addmono(&timers, timer, when);
771 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
772 timer = malloc(sizeof(*timer));
773 timer_init(timer);
774 timer_addmono(&timers, timer, when);
775 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
776 timer = malloc(sizeof(*timer));
777 timer_init(timer);
778 timer_addmono(&timers, timer, when);
779 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
780 timer = malloc(sizeof(*timer));
781 timer_init(timer);
782 timer_addmono(&timers, timer, when);
783 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
784 timer = malloc(sizeof(*timer));
785 timer_init(timer);
786 timer_addmono(&timers, timer, when);
787 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
788 timer = malloc(sizeof(*timer));
789 timer_init(timer);
790 timer_addmono(&timers, timer, when);
791 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
792 timer = malloc(sizeof(*timer));
793 timer_init(timer);
794 timer_addmono(&timers, timer, when);
795 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
796 timer = malloc(sizeof(*timer));
797 timer_init(timer);
798 timer_addmono(&timers, timer, when);
799 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
800 timer = malloc(sizeof(*timer));
801 timer_init(timer);
802 timer_addmono(&timers, timer, when);
803 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
804 timer = malloc(sizeof(*timer));
805 timer_init(timer);
806 timer_addmono(&timers, timer, when);
807 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
808 timer = malloc(sizeof(*timer));
809 timer_init(timer);
810 timer_addmono(&timers, timer, when);
811 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
812 timer = malloc(sizeof(*timer));
813 timer_init(timer);
814 timer_addmono(&timers, timer, when);
815 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
816 timer = malloc(sizeof(*timer));
817 timer_init(timer);
818 timer_addmono(&timers, timer, when);
819 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
820 timer = malloc(sizeof(*timer));
821 timer_init(timer);
822 timer_addmono(&timers, timer, when);
823 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
824 timer = malloc(sizeof(*timer));
825 timer_init(timer);
826 timer_addmono(&timers, timer, when);
827 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
828 timer = malloc(sizeof(*timer));
829 timer_init(timer);
830 timer_addmono(&timers, timer, when);
831 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
832 timer = malloc(sizeof(*timer));
833 timer_init(timer);
834 timer_addmono(&timers, timer, when);
835 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
836 timer = malloc(sizeof(*timer));
837 timer_init(timer);
838 timer_addmono(&timers, timer, when);
839 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
840 timer = malloc(sizeof(*timer));
841 timer_init(timer);
842 timer_addmono(&timers, timer, when);
843 when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
844 timer = malloc(sizeof(*timer));
845 timer_init(timer);
846 timer_addmono(&timers, timer, when);
847 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
848 timer = malloc(sizeof(*timer));
849 timer_init(timer);
850 timer_addmono(&timers, timer, when);
851 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
852 timer = malloc(sizeof(*timer));
853 timer_init(timer);
854 timer_addmono(&timers, timer, when);
855 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
856 timer = malloc(sizeof(*timer));
857 timer_init(timer);
858 timer_addmono(&timers, timer, when);
859 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
860 timer = malloc(sizeof(*timer));
861 timer_init(timer);
862 timer_addmono(&timers, timer, when);
863 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
864 timer = malloc(sizeof(*timer));
865 timer_init(timer);
866 timer_addmono(&timers, timer, when);
867 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
868 timer = malloc(sizeof(*timer));
869 timer_init(timer);
870 timer_addmono(&timers, timer, when);
871 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
872 timer = malloc(sizeof(*timer));
873 timer_init(timer);
874 timer_addmono(&timers, timer, when);
875 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
876 timer = malloc(sizeof(*timer));
877 timer_init(timer);
878 timer_addmono(&timers, timer, when);
879 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
880 timer = malloc(sizeof(*timer));
881 timer_init(timer);
882 timer_addmono(&timers, timer, when);
883 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
884 timer = malloc(sizeof(*timer));
885 timer_init(timer);
886 timer_addmono(&timers, timer, when);
887 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
888 timer = malloc(sizeof(*timer));
889 timer_init(timer);
890 timer_addmono(&timers, timer, when);
891 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
892 timer = malloc(sizeof(*timer));
893 timer_init(timer);
894 timer_addmono(&timers, timer, when);
895 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
896 timer = malloc(sizeof(*timer));
897 timer_init(timer);
898 timer_addmono(&timers, timer, when);
899 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
900 timer = malloc(sizeof(*timer));
901 timer_init(timer);
902 timer_addmono(&timers, timer, when);
903 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
904 timer = malloc(sizeof(*timer));
905 timer_init(timer);
906 timer_addmono(&timers, timer, when);
907 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
908 timer = malloc(sizeof(*timer));
909 timer_init(timer);
910 timer_addmono(&timers, timer, when);
911 when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000;
912 timer = malloc(sizeof(*timer));
913 timer_init(timer);
914 timer_addmono(&timers, timer, when);
915 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
916 timer = malloc(sizeof(*timer));
917 timer_init(timer);
918 timer_addmono(&timers, timer, when);
919 when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
920 timer = malloc(sizeof(*timer));
921 timer_init(timer);
922 timer_addmono(&timers, timer, when);
923 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
924 timer = malloc(sizeof(*timer));
925 timer_init(timer);
926 timer_addmono(&timers, timer, when);
927 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
928 timer = malloc(sizeof(*timer));
929 timer_init(timer);
930 timer_addmono(&timers, timer, when);
931 when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000;
932 timer = malloc(sizeof(*timer));
933 timer_init(timer);
934 timer_addmono(&timers, timer, when);
935 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
936 timer = malloc(sizeof(*timer));
937 timer_init(timer);
938 timer_addmono(&timers, timer, when);
939 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
940 timer = malloc(sizeof(*timer));
941 timer_init(timer);
942 timer_addmono(&timers, timer, when);
943 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
944 timer = malloc(sizeof(*timer));
945 timer_init(timer);
946 timer_addmono(&timers, timer, when);
947 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
948 timer = malloc(sizeof(*timer));
949 timer_init(timer);
950 timer_addmono(&timers, timer, when);
951 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
952 timer = malloc(sizeof(*timer));
953 timer_init(timer);
954 timer_addmono(&timers, timer, when);
955 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
956 timer = malloc(sizeof(*timer));
957 timer_init(timer);
958 timer_addmono(&timers, timer, when);
959 when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000;
960 timer = malloc(sizeof(*timer));
961 timer_init(timer);
962 timer_addmono(&timers, timer, when);
963 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
964 timer = malloc(sizeof(*timer));
965 timer_init(timer);
966 timer_addmono(&timers, timer, when);
967 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
968 timer = malloc(sizeof(*timer));
969 timer_init(timer);
970 timer_addmono(&timers, timer, when);
971 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
972 timer = malloc(sizeof(*timer));
973 timer_init(timer);
974 timer_addmono(&timers, timer, when);
975 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
976 timer = malloc(sizeof(*timer));
977 timer_init(timer);
978 timer_addmono(&timers, timer, when);
979 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
980 timer = malloc(sizeof(*timer));
981 timer_init(timer);
982 timer_addmono(&timers, timer, when);
983 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
984 timer = malloc(sizeof(*timer));
985 timer_init(timer);
986 timer_addmono(&timers, timer, when);
987 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
988 timer = malloc(sizeof(*timer));
989 timer_init(timer);
990 timer_addmono(&timers, timer, when);
991 when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000;
992 timer = malloc(sizeof(*timer));
993 timer_init(timer);
994 timer_addmono(&timers, timer, when);
995 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
996 timer = malloc(sizeof(*timer));
997 timer_init(timer);
998 timer_addmono(&timers, timer, when);
999 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1000 timer = malloc(sizeof(*timer));
1001 timer_init(timer);
1002 timer_addmono(&timers, timer, when);
1003 when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000;
1004 timer = malloc(sizeof(*timer));
1005 timer_init(timer);
1006 timer_addmono(&timers, timer, when);
1007 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1008 timer = malloc(sizeof(*timer));
1009 timer_init(timer);
1010 timer_addmono(&timers, timer, when);
1011 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
1012 timer = malloc(sizeof(*timer));
1013 timer_init(timer);
1014 timer_addmono(&timers, timer, when);
1015 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1016 timer = malloc(sizeof(*timer));
1017 timer_init(timer);
1018 timer_addmono(&timers, timer, when);
1019 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
1020 timer = malloc(sizeof(*timer));
1021 timer_init(timer);
1022 timer_addmono(&timers, timer, when);
1023 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
1024 timer = malloc(sizeof(*timer));
1025 timer_init(timer);
1026 timer_addmono(&timers, timer, when);
1027 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
1028 timer = malloc(sizeof(*timer));
1029 timer_init(timer);
1030 timer_addmono(&timers, timer, when);
1031 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1032 timer = malloc(sizeof(*timer));
1033 timer_init(timer);
1034 timer_addmono(&timers, timer, when);
1035 when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000;
1036 timer = malloc(sizeof(*timer));
1037 timer_init(timer);
1038 timer_addmono(&timers, timer, when);
1039 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
1040 timer = malloc(sizeof(*timer));
1041 timer_init(timer);
1042 timer_addmono(&timers, timer, when);
1043 when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000;
1044 timer = malloc(sizeof(*timer));
1045 timer_init(timer);
1046 timer_addmono(&timers, timer, when);
1047 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
1048 timer = malloc(sizeof(*timer));
1049 timer_init(timer);
1050 timer_addmono(&timers, timer, when);
1051 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1052 timer = malloc(sizeof(*timer));
1053 timer_init(timer);
1054 timer_addmono(&timers, timer, when);
1055 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
1056 timer = malloc(sizeof(*timer));
1057 timer_init(timer);
1058 timer_addmono(&timers, timer, when);
1059 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
1060 timer = malloc(sizeof(*timer));
1061 timer_init(timer);
1062 timer_addmono(&timers, timer, when);
1063 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1064 timer = malloc(sizeof(*timer));
1065 timer_init(timer);
1066 timer_addmono(&timers, timer, when);
1067 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1068 timer = malloc(sizeof(*timer));
1069 timer_init(timer);
1070 timer_addmono(&timers, timer, when);
1071 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1072 timer = malloc(sizeof(*timer));
1073 timer_init(timer);
1074 timer_addmono(&timers, timer, when);
1075 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
1076 timer = malloc(sizeof(*timer));
1077 timer_init(timer);
1078 timer_addmono(&timers, timer, when);
1079 when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
1080 timer = malloc(sizeof(*timer));
1081 timer_init(timer);
1082 timer_addmono(&timers, timer, when);
1083 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1084 timer = malloc(sizeof(*timer));
1085 timer_init(timer);
1086 timer_addmono(&timers, timer, when);
1087 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1088 timer = malloc(sizeof(*timer));
1089 timer_init(timer);
1090 timer_addmono(&timers, timer, when);
1091 when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000;
1092 timer = malloc(sizeof(*timer));
1093 timer_init(timer);
1094 timer_addmono(&timers, timer, when);
1095 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
1096 timer = malloc(sizeof(*timer));
1097 timer_init(timer);
1098 timer_addmono(&timers, timer, when);
1099 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1100 timer = malloc(sizeof(*timer));
1101 timer_init(timer);
1102 timer_addmono(&timers, timer, when);
1103 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
1104 timer = malloc(sizeof(*timer));
1105 timer_init(timer);
1106 timer_addmono(&timers, timer, when);
1107 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1108 timer = malloc(sizeof(*timer));
1109 timer_init(timer);
1110 timer_addmono(&timers, timer, when);
1111 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1112 timer = malloc(sizeof(*timer));
1113 timer_init(timer);
1114 timer_addmono(&timers, timer, when);
1115 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
1116 timer = malloc(sizeof(*timer));
1117 timer_init(timer);
1118 timer_addmono(&timers, timer, when);
1119 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
1120 timer = malloc(sizeof(*timer));
1121 timer_init(timer);
1122 timer_addmono(&timers, timer, when);
1123 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
1124 timer = malloc(sizeof(*timer));
1125 timer_init(timer);
1126 timer_addmono(&timers, timer, when);
1127 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
1128 timer = malloc(sizeof(*timer));
1129 timer_init(timer);
1130 timer_addmono(&timers, timer, when);
1131 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
1132 timer = malloc(sizeof(*timer));
1133 timer_init(timer);
1134 timer_addmono(&timers, timer, when);
1135 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
1136 timer = malloc(sizeof(*timer));
1137 timer_init(timer);
1138 timer_addmono(&timers, timer, when);
1139 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1140 timer = malloc(sizeof(*timer));
1141 timer_init(timer);
1142 timer_addmono(&timers, timer, when);
1143 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
1144 timer = malloc(sizeof(*timer));
1145 timer_init(timer);
1146 timer_addmono(&timers, timer, when);
1147 when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000;
1148 timer = malloc(sizeof(*timer));
1149 timer_init(timer);
1150 timer_addmono(&timers, timer, when);
1151 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
1152 timer = malloc(sizeof(*timer));
1153 timer_init(timer);
1154 timer_addmono(&timers, timer, when);
1155 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
1156 timer = malloc(sizeof(*timer));
1157 timer_init(timer);
1158 timer_addmono(&timers, timer, when);
1159 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1160 timer = malloc(sizeof(*timer));
1161 timer_init(timer);
1162 timer_addmono(&timers, timer, when);
1163 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
1164 timer = malloc(sizeof(*timer));
1165 timer_init(timer);
1166 timer_addmono(&timers, timer, when);
1167 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
1168 timer = malloc(sizeof(*timer));
1169 timer_init(timer);
1170 timer_addmono(&timers, timer, when);
1171 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
1172 timer = malloc(sizeof(*timer));
1173 timer_init(timer);
1174 timer_addmono(&timers, timer, when);
1175 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
1176 timer = malloc(sizeof(*timer));
1177 timer_init(timer);
1178 timer_addmono(&timers, timer, when);
1179 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
1180 timer = malloc(sizeof(*timer));
1181 timer_init(timer);
1182 timer_addmono(&timers, timer, when);
1183 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
1184 timer = malloc(sizeof(*timer));
1185 timer_init(timer);
1186 timer_addmono(&timers, timer, when);
1187 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
1188 timer = malloc(sizeof(*timer));
1189 timer_init(timer);
1190 timer_addmono(&timers, timer, when);
1191 when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000;
1192 timer = malloc(sizeof(*timer));
1193 timer_init(timer);
1194 timer_addmono(&timers, timer, when);
1195 when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000;
1196 timer = malloc(sizeof(*timer));
1197 timer_init(timer);
1198 timer_addmono(&timers, timer, when);
1199 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1200 timer = malloc(sizeof(*timer));
1201 timer_init(timer);
1202 timer_addmono(&timers, timer, when);
1203 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1204 timer = malloc(sizeof(*timer));
1205 timer_init(timer);
1206 timer_addmono(&timers, timer, when);
1207 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
1208 timer = malloc(sizeof(*timer));
1209 timer_init(timer);
1210 timer_addmono(&timers, timer, when);
1211 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
1212 timer = malloc(sizeof(*timer));
1213 timer_init(timer);
1214 timer_addmono(&timers, timer, when);
1215 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1216 timer = malloc(sizeof(*timer));
1217 timer_init(timer);
1218 timer_addmono(&timers, timer, when);
1219 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
1220 timer = malloc(sizeof(*timer));
1221 timer_init(timer);
1222 timer_addmono(&timers, timer, when);
1223 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
1224 timer = malloc(sizeof(*timer));
1225 timer_init(timer);
1226 timer_addmono(&timers, timer, when);
1227 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
1228 timer = malloc(sizeof(*timer));
1229 timer_init(timer);
1230 timer_addmono(&timers, timer, when);
1231 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
1232 timer = malloc(sizeof(*timer));
1233 timer_init(timer);
1234 timer_addmono(&timers, timer, when);
1235 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
1236 timer = malloc(sizeof(*timer));
1237 timer_init(timer);
1238 timer_addmono(&timers, timer, when);
1239 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
1240 timer = malloc(sizeof(*timer));
1241 timer_init(timer);
1242 timer_addmono(&timers, timer, when);
1243 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
1244 timer = malloc(sizeof(*timer));
1245 timer_init(timer);
1246 timer_addmono(&timers, timer, when);
1247 when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
1248 timer = malloc(sizeof(*timer));
1249 timer_init(timer);
1250 timer_addmono(&timers, timer, when);
1251 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
1252 timer = malloc(sizeof(*timer));
1253 timer_init(timer);
1254 timer_addmono(&timers, timer, when);
1255 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1256 timer = malloc(sizeof(*timer));
1257 timer_init(timer);
1258 timer_addmono(&timers, timer, when);
1259 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
1260 timer = malloc(sizeof(*timer));
1261 timer_init(timer);
1262 timer_addmono(&timers, timer, when);
1263 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
1264 timer = malloc(sizeof(*timer));
1265 timer_init(timer);
1266 timer_addmono(&timers, timer, when);
1267 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1268 timer = malloc(sizeof(*timer));
1269 timer_init(timer);
1270 timer_addmono(&timers, timer, when);
1271 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
1272 timer = malloc(sizeof(*timer));
1273 timer_init(timer);
1274 timer_addmono(&timers, timer, when);
1275 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
1276 timer = malloc(sizeof(*timer));
1277 timer_init(timer);
1278 timer_addmono(&timers, timer, when);
1279 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
1280 timer = malloc(sizeof(*timer));
1281 timer_init(timer);
1282 timer_addmono(&timers, timer, when);
1283 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
1284 timer = malloc(sizeof(*timer));
1285 timer_init(timer);
1286 timer_addmono(&timers, timer, when);
1287 when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000;
1288 timer = malloc(sizeof(*timer));
1289 timer_init(timer);
1290 timer_addmono(&timers, timer, when);
1291 when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000;
1292 timer = malloc(sizeof(*timer));
1293 timer_init(timer);
1294 timer_addmono(&timers, timer, when);
1295 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1296 timer = malloc(sizeof(*timer));
1297 timer_init(timer);
1298 timer_addmono(&timers, timer, when);
1299 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1300 timer = malloc(sizeof(*timer));
1301 timer_init(timer);
1302 timer_addmono(&timers, timer, when);
1303 when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
1304 timer = malloc(sizeof(*timer));
1305 timer_init(timer);
1306 timer_addmono(&timers, timer, when);
1307 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
1308 timer = malloc(sizeof(*timer));
1309 timer_init(timer);
1310 timer_addmono(&timers, timer, when);
1311 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
1312 timer = malloc(sizeof(*timer));
1313 timer_init(timer);
1314 timer_addmono(&timers, timer, when);
1315 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1316 timer = malloc(sizeof(*timer));
1317 timer_init(timer);
1318 timer_addmono(&timers, timer, when);
1319 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
1320 timer = malloc(sizeof(*timer));
1321 timer_init(timer);
1322 timer_addmono(&timers, timer, when);
1323 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
1324 timer = malloc(sizeof(*timer));
1325 timer_init(timer);
1326 timer_addmono(&timers, timer, when);
1327 when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000;
1328 timer = malloc(sizeof(*timer));
1329 timer_init(timer);
1330 timer_addmono(&timers, timer, when);
1331 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
1332 timer = malloc(sizeof(*timer));
1333 timer_init(timer);
1334 timer_addmono(&timers, timer, when);
1335 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1336 timer = malloc(sizeof(*timer));
1337 timer_init(timer);
1338 timer_addmono(&timers, timer, when);
1339 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
1340 timer = malloc(sizeof(*timer));
1341 timer_init(timer);
1342 timer_addmono(&timers, timer, when);
1343 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
1344 timer = malloc(sizeof(*timer));
1345 timer_init(timer);
1346 timer_addmono(&timers, timer, when);
1347 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
1348 timer = malloc(sizeof(*timer));
1349 timer_init(timer);
1350 timer_addmono(&timers, timer, when);
1351 when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000;
1352 timer = malloc(sizeof(*timer));
1353 timer_init(timer);
1354 timer_addmono(&timers, timer, when);
1355 when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000;
1356 timer = malloc(sizeof(*timer));
1357 timer_init(timer);
1358 timer_addmono(&timers, timer, when);
1359 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
1360 timer = malloc(sizeof(*timer));
1361 timer_init(timer);
1362 timer_addmono(&timers, timer, when);
1363 when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
1364 timer = malloc(sizeof(*timer));
1365 timer_init(timer);
1366 timer_addmono(&timers, timer, when);
1367 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
1368 timer = malloc(sizeof(*timer));
1369 timer_init(timer);
1370 timer_addmono(&timers, timer, when);
1371 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
1372 timer = malloc(sizeof(*timer));
1373 timer_init(timer);
1374 timer_addmono(&timers, timer, when);
1375 when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000;
1376 timer = malloc(sizeof(*timer));
1377 timer_init(timer);
1378 timer_addmono(&timers, timer, when);
1379 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
1380 timer = malloc(sizeof(*timer));
1381 timer_init(timer);
1382 timer_addmono(&timers, timer, when);
1383 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
1384 timer = malloc(sizeof(*timer));
1385 timer_init(timer);
1386 timer_addmono(&timers, timer, when);
1387 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
1388 timer = malloc(sizeof(*timer));
1389 timer_init(timer);
1390 timer_addmono(&timers, timer, when);
1391 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1392 timer = malloc(sizeof(*timer));
1393 timer_init(timer);
1394 timer_addmono(&timers, timer, when);
1395 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
1396 timer = malloc(sizeof(*timer));
1397 timer_init(timer);
1398 timer_addmono(&timers, timer, when);
1399 when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000;
1400 timer = malloc(sizeof(*timer));
1401 timer_init(timer);
1402 timer_addmono(&timers, timer, when);
1403 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
1404 timer = malloc(sizeof(*timer));
1405 timer_init(timer);
1406 timer_addmono(&timers, timer, when);
1407 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
1408 timer = malloc(sizeof(*timer));
1409 timer_init(timer);
1410 timer_addmono(&timers, timer, when);
1411 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
1412 timer = malloc(sizeof(*timer));
1413 timer_init(timer);
1414 timer_addmono(&timers, timer, when);
1415 when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
1416 timer = malloc(sizeof(*timer));
1417 timer_init(timer);
1418 timer_addmono(&timers, timer, when);
1419 when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
1420 timer = malloc(sizeof(*timer));
1421 timer_init(timer);
1422 timer_addmono(&timers, timer, when);
1423 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1424 timer = malloc(sizeof(*timer));
1425 timer_init(timer);
1426 timer_addmono(&timers, timer, when);
1427 when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000;
1428 timer = malloc(sizeof(*timer));
1429 timer_init(timer);
1430 timer_addmono(&timers, timer, when);
1431 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
1432 timer = malloc(sizeof(*timer));
1433 timer_init(timer);
1434 timer_addmono(&timers, timer, when);
1435 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
1436 timer = malloc(sizeof(*timer));
1437 timer_init(timer);
1438 timer_addmono(&timers, timer, when);
1439 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
1440 timer = malloc(sizeof(*timer));
1441 timer_init(timer);
1442 timer_addmono(&timers, timer, when);
1443 when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000;
1444 timer = malloc(sizeof(*timer));
1445 timer_init(timer);
1446 timer_addmono(&timers, timer, when);
1447 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1448 timer = malloc(sizeof(*timer));
1449 timer_init(timer);
1450 timer_addmono(&timers, timer, when);
1451 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
1452 timer = malloc(sizeof(*timer));
1453 timer_init(timer);
1454 timer_addmono(&timers, timer, when);
1455 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
1456 timer = malloc(sizeof(*timer));
1457 timer_init(timer);
1458 timer_addmono(&timers, timer, when);
1459 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
1460 timer = malloc(sizeof(*timer));
1461 timer_init(timer);
1462 timer_addmono(&timers, timer, when);
1463 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1464 timer = malloc(sizeof(*timer));
1465 timer_init(timer);
1466 timer_addmono(&timers, timer, when);
1467 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
1468 timer = malloc(sizeof(*timer));
1469 timer_init(timer);
1470 timer_addmono(&timers, timer, when);
1471 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
1472 timer = malloc(sizeof(*timer));
1473 timer_init(timer);
1474 timer_addmono(&timers, timer, when);
1475 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
1476 timer = malloc(sizeof(*timer));
1477 timer_init(timer);
1478 timer_addmono(&timers, timer, when);
1479 when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000;
1480 timer = malloc(sizeof(*timer));
1481 timer_init(timer);
1482 timer_addmono(&timers, timer, when);
1483 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
1484 timer = malloc(sizeof(*timer));
1485 timer_init(timer);
1486 timer_addmono(&timers, timer, when);
1487 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1488 timer = malloc(sizeof(*timer));
1489 timer_init(timer);
1490 timer_addmono(&timers, timer, when);
1491 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1492 timer = malloc(sizeof(*timer));
1493 timer_init(timer);
1494 timer_addmono(&timers, timer, when);
1495 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
1496 timer = malloc(sizeof(*timer));
1497 timer_init(timer);
1498 timer_addmono(&timers, timer, when);
1499 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
1500 timer = malloc(sizeof(*timer));
1501 timer_init(timer);
1502 timer_addmono(&timers, timer, when);
1503 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1504 timer = malloc(sizeof(*timer));
1505 timer_init(timer);
1506 timer_addmono(&timers, timer, when);
1507 when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000;
1508 timer = malloc(sizeof(*timer));
1509 timer_init(timer);
1510 timer_addmono(&timers, timer, when);
1511 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1512 timer = malloc(sizeof(*timer));
1513 timer_init(timer);
1514 timer_addmono(&timers, timer, when);
1515 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1516 timer = malloc(sizeof(*timer));
1517 timer_init(timer);
1518 timer_addmono(&timers, timer, when);
1519 when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000;
1520 timer = malloc(sizeof(*timer));
1521 timer_init(timer);
1522 timer_addmono(&timers, timer, when);
1523 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1524 timer = malloc(sizeof(*timer));
1525 timer_init(timer);
1526 timer_addmono(&timers, timer, when);
1527 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
1528 timer = malloc(sizeof(*timer));
1529 timer_init(timer);
1530 timer_addmono(&timers, timer, when);
1531 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
1532 timer = malloc(sizeof(*timer));
1533 timer_init(timer);
1534 timer_addmono(&timers, timer, when);
1535 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
1536 timer = malloc(sizeof(*timer));
1537 timer_init(timer);
1538 timer_addmono(&timers, timer, when);
1539 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
1540 timer = malloc(sizeof(*timer));
1541 timer_init(timer);
1542 timer_addmono(&timers, timer, when);
1543 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1544 timer = malloc(sizeof(*timer));
1545 timer_init(timer);
1546 timer_addmono(&timers, timer, when);
1547 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
1548 timer = malloc(sizeof(*timer));
1549 timer_init(timer);
1550 timer_addmono(&timers, timer, when);
1551 when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000;
1552 timer = malloc(sizeof(*timer));
1553 timer_init(timer);
1554 timer_addmono(&timers, timer, when);
1555 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
1556 timer = malloc(sizeof(*timer));
1557 timer_init(timer);
1558 timer_addmono(&timers, timer, when);
1559 when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000;
1560 timer = malloc(sizeof(*timer));
1561 timer_init(timer);
1562 timer_addmono(&timers, timer, when);
1563 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1564 timer = malloc(sizeof(*timer));
1565 timer_init(timer);
1566 timer_addmono(&timers, timer, when);
1567 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
1568 timer = malloc(sizeof(*timer));
1569 timer_init(timer);
1570 timer_addmono(&timers, timer, when);
1571 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
1572 timer = malloc(sizeof(*timer));
1573 timer_init(timer);
1574 timer_addmono(&timers, timer, when);
1575 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
1576 timer = malloc(sizeof(*timer));
1577 timer_init(timer);
1578 timer_addmono(&timers, timer, when);
1579 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1580 timer = malloc(sizeof(*timer));
1581 timer_init(timer);
1582 timer_addmono(&timers, timer, when);
1583 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
1584 timer = malloc(sizeof(*timer));
1585 timer_init(timer);
1586 timer_addmono(&timers, timer, when);
1587 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
1588 timer = malloc(sizeof(*timer));
1589 timer_init(timer);
1590 timer_addmono(&timers, timer, when);
1591 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1592 timer = malloc(sizeof(*timer));
1593 timer_init(timer);
1594 timer_addmono(&timers, timer, when);
1595 when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000;
1596 timer = malloc(sizeof(*timer));
1597 timer_init(timer);
1598 timer_addmono(&timers, timer, when);
1599 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1600 timer = malloc(sizeof(*timer));
1601 timer_init(timer);
1602 timer_addmono(&timers, timer, when);
1603 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
1604 timer = malloc(sizeof(*timer));
1605 timer_init(timer);
1606 timer_addmono(&timers, timer, when);
1607 when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000;
1608 timer = malloc(sizeof(*timer));
1609 timer_init(timer);
1610 timer_addmono(&timers, timer, when);
1611 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
1612 timer = malloc(sizeof(*timer));
1613 timer_init(timer);
1614 timer_addmono(&timers, timer, when);
1615 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1616 timer = malloc(sizeof(*timer));
1617 timer_init(timer);
1618 timer_addmono(&timers, timer, when);
1619 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
1620 timer = malloc(sizeof(*timer));
1621 timer_init(timer);
1622 timer_addmono(&timers, timer, when);
1623 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
1624 timer = malloc(sizeof(*timer));
1625 timer_init(timer);
1626 timer_addmono(&timers, timer, when);
1627 timer_earliest(&timers, &when);
1628 free(timers_expire(&timers, when));
1629 timer_earliest(&timers, &when);
1630 free(timers_expire(&timers, when));
1631 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1632 timer = malloc(sizeof(*timer));
1633 timer_init(timer);
1634 timer_addmono(&timers, timer, when);
1635 when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
1636 timer = malloc(sizeof(*timer));
1637 timer_init(timer);
1638 timer_addmono(&timers, timer, when);
1639 when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1640 timer = malloc(sizeof(*timer));
1641 timer_init(timer);
1642 timer_addmono(&timers, timer, when);
1643 timer_earliest(&timers, &when);
1644 free(timers_expire(&timers, when));
1645 when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
1646 timer = malloc(sizeof(*timer));
1647 timer_init(timer);
1648 timer_addmono(&timers, timer, when);
1649 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1650 timer = malloc(sizeof(*timer));
1651 timer_init(timer);
1652 timer_addmono(&timers, timer, when);
1653 timer_earliest(&timers, &when);
1654 free(timers_expire(&timers, when));
1655 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
1656 timer = malloc(sizeof(*timer));
1657 timer_init(timer);
1658 timer_addmono(&timers, timer, when);
1659 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
1660 timer = malloc(sizeof(*timer));
1661 timer_init(timer);
1662 timer_addmono(&timers, timer, when);
1663 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1664 timer = malloc(sizeof(*timer));
1665 timer_init(timer);
1666 timer_addmono(&timers, timer, when);
1667 when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
1668 timer = malloc(sizeof(*timer));
1669 timer_init(timer);
1670 timer_addmono(&timers, timer, when);
1671 timer_earliest(&timers, &when);
1672 free(timers_expire(&timers, when));
1673 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1674 timer = malloc(sizeof(*timer));
1675 timer_init(timer);
1676 timer_addmono(&timers, timer, when);
1677 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
1678 timer = malloc(sizeof(*timer));
1679 timer_init(timer);
1680 timer_addmono(&timers, timer, when);
1681 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1682 timer = malloc(sizeof(*timer));
1683 timer_init(timer);
1684 timer_addmono(&timers, timer, when);
1685 timer_earliest(&timers, &when);
1686 free(timers_expire(&timers, when));
1687 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1688 timer = malloc(sizeof(*timer));
1689 timer_init(timer);
1690 timer_addmono(&timers, timer, when);
1691 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1692 timer = malloc(sizeof(*timer));
1693 timer_init(timer);
1694 timer_addmono(&timers, timer, when);
1695 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1696 timer = malloc(sizeof(*timer));
1697 timer_init(timer);
1698 timer_addmono(&timers, timer, when);
1699 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1700 timer = malloc(sizeof(*timer));
1701 timer_init(timer);
1702 timer_addmono(&timers, timer, when);
1703 when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
1704 timer = malloc(sizeof(*timer));
1705 timer_init(timer);
1706 timer_addmono(&timers, timer, when);
1707 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1708 timer = malloc(sizeof(*timer));
1709 timer_init(timer);
1710 timer_addmono(&timers, timer, when);
1711 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
1712 timer = malloc(sizeof(*timer));
1713 timer_init(timer);
1714 timer_addmono(&timers, timer, when);
1715 timer_earliest(&timers, &when);
1716 free(timers_expire(&timers, when));
1717 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1718 timer = malloc(sizeof(*timer));
1719 timer_init(timer);
1720 timer_addmono(&timers, timer, when);
1721 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
1722 timer = malloc(sizeof(*timer));
1723 timer_init(timer);
1724 timer_addmono(&timers, timer, when);
1725 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
1726 timer = malloc(sizeof(*timer));
1727 timer_init(timer);
1728 timer_addmono(&timers, timer, when);
1729 timer_earliest(&timers, &when);
1730 free(timers_expire(&timers, when));
1731 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1732 timer = malloc(sizeof(*timer));
1733 timer_init(timer);
1734 timer_addmono(&timers, timer, when);
1735 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
1736 timer = malloc(sizeof(*timer));
1737 timer_init(timer);
1738 timer_addmono(&timers, timer, when);
1739 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
1740 timer = malloc(sizeof(*timer));
1741 timer_init(timer);
1742 timer_addmono(&timers, timer, when);
1743 timer_earliest(&timers, &when);
1744 free(timers_expire(&timers, when));
1745 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1746 timer = malloc(sizeof(*timer));
1747 timer_init(timer);
1748 timer_addmono(&timers, timer, when);
1749 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1750 timer = malloc(sizeof(*timer));
1751 timer_init(timer);
1752 timer_addmono(&timers, timer, when);
1753 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1754 timer = malloc(sizeof(*timer));
1755 timer_init(timer);
1756 timer_addmono(&timers, timer, when);
1757 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
1758 timer = malloc(sizeof(*timer));
1759 timer_init(timer);
1760 timer_addmono(&timers, timer, when);
1761 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1762 timer = malloc(sizeof(*timer));
1763 timer_init(timer);
1764 timer_addmono(&timers, timer, when);
1765 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
1766 timer = malloc(sizeof(*timer));
1767 timer_init(timer);
1768 timer_addmono(&timers, timer, when);
1769 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1770 timer = malloc(sizeof(*timer));
1771 timer_init(timer);
1772 timer_addmono(&timers, timer, when);
1773 timer_earliest(&timers, &when);
1774 free(timers_expire(&timers, when));
1775 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1776 timer = malloc(sizeof(*timer));
1777 timer_init(timer);
1778 timer_addmono(&timers, timer, when);
1779 when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
1780 timer = malloc(sizeof(*timer));
1781 timer_init(timer);
1782 timer_addmono(&timers, timer, when);
1783 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
1784 timer = malloc(sizeof(*timer));
1785 timer_init(timer);
1786 timer_addmono(&timers, timer, when);
1787 timer_earliest(&timers, &when);
1788 free(timers_expire(&timers, when));
1789 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1790 timer = malloc(sizeof(*timer));
1791 timer_init(timer);
1792 timer_addmono(&timers, timer, when);
1793 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1794 timer = malloc(sizeof(*timer));
1795 timer_init(timer);
1796 timer_addmono(&timers, timer, when);
1797 when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
1798 timer = malloc(sizeof(*timer));
1799 timer_init(timer);
1800 timer_addmono(&timers, timer, when);
1801 timer_earliest(&timers, &when);
1802 free(timers_expire(&timers, when));
1803 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
1804 timer = malloc(sizeof(*timer));
1805 timer_init(timer);
1806 timer_addmono(&timers, timer, when);
1807 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
1808 timer = malloc(sizeof(*timer));
1809 timer_init(timer);
1810 timer_addmono(&timers, timer, when);
1811 when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1812 timer = malloc(sizeof(*timer));
1813 timer_init(timer);
1814 timer_addmono(&timers, timer, when);
1815 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
1816 timer = malloc(sizeof(*timer));
1817 timer_init(timer);
1818 timer_addmono(&timers, timer, when);
1819 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1820 timer = malloc(sizeof(*timer));
1821 timer_init(timer);
1822 timer_addmono(&timers, timer, when);
1823 timer_earliest(&timers, &when);
1824 free(timers_expire(&timers, when));
1825 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1826 timer = malloc(sizeof(*timer));
1827 timer_init(timer);
1828 timer_addmono(&timers, timer, when);
1829 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1830 timer = malloc(sizeof(*timer));
1831 timer_init(timer);
1832 timer_addmono(&timers, timer, when);
1833 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
1834 timer = malloc(sizeof(*timer));
1835 timer_init(timer);
1836 timer_addmono(&timers, timer, when);
1837 timer_earliest(&timers, &when);
1838 free(timers_expire(&timers, when));
1839 when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
1840 timer = malloc(sizeof(*timer));
1841 timer_init(timer);
1842 timer_addmono(&timers, timer, when);
1843 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
1844 timer = malloc(sizeof(*timer));
1845 timer_init(timer);
1846 timer_addmono(&timers, timer, when);
1847 timer_earliest(&timers, &when);
1848 free(timers_expire(&timers, when));
1849 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1850 timer = malloc(sizeof(*timer));
1851 timer_init(timer);
1852 timer_addmono(&timers, timer, when);
1853 timer_earliest(&timers, &when);
1854 free(timers_expire(&timers, when));
1855 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1856 timer = malloc(sizeof(*timer));
1857 timer_init(timer);
1858 timer_addmono(&timers, timer, when);
1859 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1860 timer = malloc(sizeof(*timer));
1861 timer_init(timer);
1862 timer_addmono(&timers, timer, when);
1863 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1864 timer = malloc(sizeof(*timer));
1865 timer_init(timer);
1866 timer_addmono(&timers, timer, when);
1867 timer_earliest(&timers, &when);
1868 free(timers_expire(&timers, when));
1869 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1870 timer = malloc(sizeof(*timer));
1871 timer_init(timer);
1872 timer_addmono(&timers, timer, when);
1873 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
1874 timer = malloc(sizeof(*timer));
1875 timer_init(timer);
1876 timer_addmono(&timers, timer, when);
1877 when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
1878 timer = malloc(sizeof(*timer));
1879 timer_init(timer);
1880 timer_addmono(&timers, timer, when);
1881 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
1882 timer = malloc(sizeof(*timer));
1883 timer_init(timer);
1884 timer_addmono(&timers, timer, when);
1885 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
1886 timer = malloc(sizeof(*timer));
1887 timer_init(timer);
1888 timer_addmono(&timers, timer, when);
1889 timer_earliest(&timers, &when);
1890 free(timers_expire(&timers, when));
1891 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1892 timer = malloc(sizeof(*timer));
1893 timer_init(timer);
1894 timer_addmono(&timers, timer, when);
1895 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
1896 timer = malloc(sizeof(*timer));
1897 timer_init(timer);
1898 timer_addmono(&timers, timer, when);
1899 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
1900 timer = malloc(sizeof(*timer));
1901 timer_init(timer);
1902 timer_addmono(&timers, timer, when);
1903 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
1904 timer = malloc(sizeof(*timer));
1905 timer_init(timer);
1906 timer_addmono(&timers, timer, when);
1907 when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
1908 timer = malloc(sizeof(*timer));
1909 timer_init(timer);
1910 timer_addmono(&timers, timer, when);
1911 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
1912 timer = malloc(sizeof(*timer));
1913 timer_init(timer);
1914 timer_addmono(&timers, timer, when);
1915 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1916 timer = malloc(sizeof(*timer));
1917 timer_init(timer);
1918 timer_addmono(&timers, timer, when);
1919 timer_earliest(&timers, &when);
1920 free(timers_expire(&timers, when));
1921 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1922 timer = malloc(sizeof(*timer));
1923 timer_init(timer);
1924 timer_addmono(&timers, timer, when);
1925 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
1926 timer = malloc(sizeof(*timer));
1927 timer_init(timer);
1928 timer_addmono(&timers, timer, when);
1929 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1930 timer = malloc(sizeof(*timer));
1931 timer_init(timer);
1932 timer_addmono(&timers, timer, when);
1933 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1934 timer = malloc(sizeof(*timer));
1935 timer_init(timer);
1936 timer_addmono(&timers, timer, when);
1937 when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
1938 timer = malloc(sizeof(*timer));
1939 timer_init(timer);
1940 timer_addmono(&timers, timer, when);
1941 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1942 timer = malloc(sizeof(*timer));
1943 timer_init(timer);
1944 timer_addmono(&timers, timer, when);
1945 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1946 timer = malloc(sizeof(*timer));
1947 timer_init(timer);
1948 timer_addmono(&timers, timer, when);
1949 timer_earliest(&timers, &when);
1950 free(timers_expire(&timers, when));
1951 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
1952 timer = malloc(sizeof(*timer));
1953 timer_init(timer);
1954 timer_addmono(&timers, timer, when);
1955 when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
1956 timer = malloc(sizeof(*timer));
1957 timer_init(timer);
1958 timer_addmono(&timers, timer, when);
1959 timer_earliest(&timers, &when);
1960 free(timers_expire(&timers, when));
1961 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1962 timer = malloc(sizeof(*timer));
1963 timer_init(timer);
1964 timer_addmono(&timers, timer, when);
1965 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1966 timer = malloc(sizeof(*timer));
1967 timer_init(timer);
1968 timer_addmono(&timers, timer, when);
1969 when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
1970 timer = malloc(sizeof(*timer));
1971 timer_init(timer);
1972 timer_addmono(&timers, timer, when);
1973 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
1974 timer = malloc(sizeof(*timer));
1975 timer_init(timer);
1976 timer_addmono(&timers, timer, when);
1977 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
1978 timer = malloc(sizeof(*timer));
1979 timer_init(timer);
1980 timer_addmono(&timers, timer, when);
1981 timer_earliest(&timers, &when);
1982 free(timers_expire(&timers, when));
1983 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1984 timer = malloc(sizeof(*timer));
1985 timer_init(timer);
1986 timer_addmono(&timers, timer, when);
1987 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1988 timer = malloc(sizeof(*timer));
1989 timer_init(timer);
1990 timer_addmono(&timers, timer, when);
1991 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
1992 timer = malloc(sizeof(*timer));
1993 timer_init(timer);
1994 timer_addmono(&timers, timer, when);
1995 timer_earliest(&timers, &when);
1996 free(timers_expire(&timers, when));
1997 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
1998 timer = malloc(sizeof(*timer));
1999 timer_init(timer);
2000 timer_addmono(&timers, timer, when);
2001 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2002 timer = malloc(sizeof(*timer));
2003 timer_init(timer);
2004 timer_addmono(&timers, timer, when);
2005 timer_earliest(&timers, &when);
2006 free(timers_expire(&timers, when));
2007 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
2008 timer = malloc(sizeof(*timer));
2009 timer_init(timer);
2010 timer_addmono(&timers, timer, when);
2011 when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
2012 timer = malloc(sizeof(*timer));
2013 timer_init(timer);
2014 timer_addmono(&timers, timer, when);
2015 timer_earliest(&timers, &when);
2016 free(timers_expire(&timers, when));
2017 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2018 timer = malloc(sizeof(*timer));
2019 timer_init(timer);
2020 timer_addmono(&timers, timer, when);
2021 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2022 timer = malloc(sizeof(*timer));
2023 timer_init(timer);
2024 timer_addmono(&timers, timer, when);
2025 when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
2026 timer = malloc(sizeof(*timer));
2027 timer_init(timer);
2028 timer_addmono(&timers, timer, when);
2029 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
2030 timer = malloc(sizeof(*timer));
2031 timer_init(timer);
2032 timer_addmono(&timers, timer, when);
2033 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
2034 timer = malloc(sizeof(*timer));
2035 timer_init(timer);
2036 timer_addmono(&timers, timer, when);
2037 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2038 timer = malloc(sizeof(*timer));
2039 timer_init(timer);
2040 timer_addmono(&timers, timer, when);
2041 timer_earliest(&timers, &when);
2042 free(timers_expire(&timers, when));
2043 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2044 timer = malloc(sizeof(*timer));
2045 timer_init(timer);
2046 timer_addmono(&timers, timer, when);
2047 when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2048 timer = malloc(sizeof(*timer));
2049 timer_init(timer);
2050 timer_addmono(&timers, timer, when);
2051 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2052 timer = malloc(sizeof(*timer));
2053 timer_init(timer);
2054 timer_addmono(&timers, timer, when);
2055 timer_earliest(&timers, &when);
2056 free(timers_expire(&timers, when));
2057 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2058 timer = malloc(sizeof(*timer));
2059 timer_init(timer);
2060 timer_addmono(&timers, timer, when);
2061 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2062 timer = malloc(sizeof(*timer));
2063 timer_init(timer);
2064 timer_addmono(&timers, timer, when);
2065 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2066 timer = malloc(sizeof(*timer));
2067 timer_init(timer);
2068 timer_addmono(&timers, timer, when);
2069 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2070 timer = malloc(sizeof(*timer));
2071 timer_init(timer);
2072 timer_addmono(&timers, timer, when);
2073 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
2074 timer = malloc(sizeof(*timer));
2075 timer_init(timer);
2076 timer_addmono(&timers, timer, when);
2077 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2078 timer = malloc(sizeof(*timer));
2079 timer_init(timer);
2080 timer_addmono(&timers, timer, when);
2081 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
2082 timer = malloc(sizeof(*timer));
2083 timer_init(timer);
2084 timer_addmono(&timers, timer, when);
2085 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
2086 timer = malloc(sizeof(*timer));
2087 timer_init(timer);
2088 timer_addmono(&timers, timer, when);
2089 timer_earliest(&timers, &when);
2090 free(timers_expire(&timers, when));
2091 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2092 timer = malloc(sizeof(*timer));
2093 timer_init(timer);
2094 timer_addmono(&timers, timer, when);
2095 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
2096 timer = malloc(sizeof(*timer));
2097 timer_init(timer);
2098 timer_addmono(&timers, timer, when);
2099 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2100 timer = malloc(sizeof(*timer));
2101 timer_init(timer);
2102 timer_addmono(&timers, timer, when);
2103 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2104 timer = malloc(sizeof(*timer));
2105 timer_init(timer);
2106 timer_addmono(&timers, timer, when);
2107 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2108 timer = malloc(sizeof(*timer));
2109 timer_init(timer);
2110 timer_addmono(&timers, timer, when);
2111 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2112 timer = malloc(sizeof(*timer));
2113 timer_init(timer);
2114 timer_addmono(&timers, timer, when);
2115 timer_earliest(&timers, &when);
2116 free(timers_expire(&timers, when));
2117 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2118 timer = malloc(sizeof(*timer));
2119 timer_init(timer);
2120 timer_addmono(&timers, timer, when);
2121 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
2122 timer = malloc(sizeof(*timer));
2123 timer_init(timer);
2124 timer_addmono(&timers, timer, when);
2125 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2126 timer = malloc(sizeof(*timer));
2127 timer_init(timer);
2128 timer_addmono(&timers, timer, when);
2129 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2130 timer = malloc(sizeof(*timer));
2131 timer_init(timer);
2132 timer_addmono(&timers, timer, when);
2133 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
2134 timer = malloc(sizeof(*timer));
2135 timer_init(timer);
2136 timer_addmono(&timers, timer, when);
2137 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2138 timer = malloc(sizeof(*timer));
2139 timer_init(timer);
2140 timer_addmono(&timers, timer, when);
2141 when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
2142 timer = malloc(sizeof(*timer));
2143 timer_init(timer);
2144 timer_addmono(&timers, timer, when);
2145 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
2146 timer = malloc(sizeof(*timer));
2147 timer_init(timer);
2148 timer_addmono(&timers, timer, when);
2149 timer_earliest(&timers, &when);
2150 free(timers_expire(&timers, when));
2151 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2152 timer = malloc(sizeof(*timer));
2153 timer_init(timer);
2154 timer_addmono(&timers, timer, when);
2155 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
2156 timer = malloc(sizeof(*timer));
2157 timer_init(timer);
2158 timer_addmono(&timers, timer, when);
2159 when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000;
2160 timer = malloc(sizeof(*timer));
2161 timer_init(timer);
2162 timer_addmono(&timers, timer, when);
2163 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2164 timer = malloc(sizeof(*timer));
2165 timer_init(timer);
2166 timer_addmono(&timers, timer, when);
2167 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
2168 timer = malloc(sizeof(*timer));
2169 timer_init(timer);
2170 timer_addmono(&timers, timer, when);
2171 timer_earliest(&timers, &when);
2172 free(timers_expire(&timers, when));
2173 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2174 timer = malloc(sizeof(*timer));
2175 timer_init(timer);
2176 timer_addmono(&timers, timer, when);
2177 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2178 timer = malloc(sizeof(*timer));
2179 timer_init(timer);
2180 timer_addmono(&timers, timer, when);
2181 timer_earliest(&timers, &when);
2182 free(timers_expire(&timers, when));
2183 timer_earliest(&timers, &when);
2184 free(timers_expire(&timers, when));
2185 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2186 timer = malloc(sizeof(*timer));
2187 timer_init(timer);
2188 timer_addmono(&timers, timer, when);
2189 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2190 timer = malloc(sizeof(*timer));
2191 timer_init(timer);
2192 timer_addmono(&timers, timer, when);
2193 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2194 timer = malloc(sizeof(*timer));
2195 timer_init(timer);
2196 timer_addmono(&timers, timer, when);
2197 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2198 timer = malloc(sizeof(*timer));
2199 timer_init(timer);
2200 timer_addmono(&timers, timer, when);
2201 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2202 timer = malloc(sizeof(*timer));
2203 timer_init(timer);
2204 timer_addmono(&timers, timer, when);
2205 timer_earliest(&timers, &when);
2206 free(timers_expire(&timers, when));
2207 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
2208 timer = malloc(sizeof(*timer));
2209 timer_init(timer);
2210 timer_addmono(&timers, timer, when);
2211 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
2212 timer = malloc(sizeof(*timer));
2213 timer_init(timer);
2214 timer_addmono(&timers, timer, when);
2215 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2216 timer = malloc(sizeof(*timer));
2217 timer_init(timer);
2218 timer_addmono(&timers, timer, when);
2219 timer_earliest(&timers, &when);
2220 free(timers_expire(&timers, when));
2221 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
2222 timer = malloc(sizeof(*timer));
2223 timer_init(timer);
2224 timer_addmono(&timers, timer, when);
2225 when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
2226 timer = malloc(sizeof(*timer));
2227 timer_init(timer);
2228 timer_addmono(&timers, timer, when);
2229 timer_earliest(&timers, &when);
2230 free(timers_expire(&timers, when));
2231 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
2232 timer = malloc(sizeof(*timer));
2233 timer_init(timer);
2234 timer_addmono(&timers, timer, when);
2235 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2236 timer = malloc(sizeof(*timer));
2237 timer_init(timer);
2238 timer_addmono(&timers, timer, when);
2239 when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
2240 timer = malloc(sizeof(*timer));
2241 timer_init(timer);
2242 timer_addmono(&timers, timer, when);
2243 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2244 timer = malloc(sizeof(*timer));
2245 timer_init(timer);
2246 timer_addmono(&timers, timer, when);
2247 timer_earliest(&timers, &when);
2248 free(timers_expire(&timers, when));
2249 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2250 timer = malloc(sizeof(*timer));
2251 timer_init(timer);
2252 timer_addmono(&timers, timer, when);
2253 timer_earliest(&timers, &when);
2254 free(timers_expire(&timers, when));
2255 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2256 timer = malloc(sizeof(*timer));
2257 timer_init(timer);
2258 timer_addmono(&timers, timer, when);
2259 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2260 timer = malloc(sizeof(*timer));
2261 timer_init(timer);
2262 timer_addmono(&timers, timer, when);
2263 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2264 timer = malloc(sizeof(*timer));
2265 timer_init(timer);
2266 timer_addmono(&timers, timer, when);
2267 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2268 timer = malloc(sizeof(*timer));
2269 timer_init(timer);
2270 timer_addmono(&timers, timer, when);
2271 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2272 timer = malloc(sizeof(*timer));
2273 timer_init(timer);
2274 timer_addmono(&timers, timer, when);
2275 timer_earliest(&timers, &when);
2276 free(timers_expire(&timers, when));
2277 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2278 timer = malloc(sizeof(*timer));
2279 timer_init(timer);
2280 timer_addmono(&timers, timer, when);
2281 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2282 timer = malloc(sizeof(*timer));
2283 timer_init(timer);
2284 timer_addmono(&timers, timer, when);
2285 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
2286 timer = malloc(sizeof(*timer));
2287 timer_init(timer);
2288 timer_addmono(&timers, timer, when);
2289 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2290 timer = malloc(sizeof(*timer));
2291 timer_init(timer);
2292 timer_addmono(&timers, timer, when);
2293 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2294 timer = malloc(sizeof(*timer));
2295 timer_init(timer);
2296 timer_addmono(&timers, timer, when);
2297 timer_earliest(&timers, &when);
2298 free(timers_expire(&timers, when));
2299 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2300 timer = malloc(sizeof(*timer));
2301 timer_init(timer);
2302 timer_addmono(&timers, timer, when);
2303 when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2304 timer = malloc(sizeof(*timer));
2305 timer_init(timer);
2306 timer_addmono(&timers, timer, when);
2307 timer_earliest(&timers, &when);
2308 free(timers_expire(&timers, when));
2309 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2310 timer = malloc(sizeof(*timer));
2311 timer_init(timer);
2312 timer_addmono(&timers, timer, when);
2313 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2314 timer = malloc(sizeof(*timer));
2315 timer_init(timer);
2316 timer_addmono(&timers, timer, when);
2317 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2318 timer = malloc(sizeof(*timer));
2319 timer_init(timer);
2320 timer_addmono(&timers, timer, when);
2321 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2322 timer = malloc(sizeof(*timer));
2323 timer_init(timer);
2324 timer_addmono(&timers, timer, when);
2325 when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
2326 timer = malloc(sizeof(*timer));
2327 timer_init(timer);
2328 timer_addmono(&timers, timer, when);
2329 timer_earliest(&timers, &when);
2330 free(timers_expire(&timers, when));
2331 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
2332 timer = malloc(sizeof(*timer));
2333 timer_init(timer);
2334 timer_addmono(&timers, timer, when);
2335 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2336 timer = malloc(sizeof(*timer));
2337 timer_init(timer);
2338 timer_addmono(&timers, timer, when);
2339 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2340 timer = malloc(sizeof(*timer));
2341 timer_init(timer);
2342 timer_addmono(&timers, timer, when);
2343 when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
2344 timer = malloc(sizeof(*timer));
2345 timer_init(timer);
2346 timer_addmono(&timers, timer, when);
2347 timer_earliest(&timers, &when);
2348 free(timers_expire(&timers, when));
2349 timer_earliest(&timers, &when);
2350 free(timers_expire(&timers, when));
2351 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2352 timer = malloc(sizeof(*timer));
2353 timer_init(timer);
2354 timer_addmono(&timers, timer, when);
2355 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2356 timer = malloc(sizeof(*timer));
2357 timer_init(timer);
2358 timer_addmono(&timers, timer, when);
2359 when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
2360 timer = malloc(sizeof(*timer));
2361 timer_init(timer);
2362 timer_addmono(&timers, timer, when);
2363 timer_earliest(&timers, &when);
2364 free(timers_expire(&timers, when));
2365 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2366 timer = malloc(sizeof(*timer));
2367 timer_init(timer);
2368 timer_addmono(&timers, timer, when);
2369 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2370 timer = malloc(sizeof(*timer));
2371 timer_init(timer);
2372 timer_addmono(&timers, timer, when);
2373 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2374 timer = malloc(sizeof(*timer));
2375 timer_init(timer);
2376 timer_addmono(&timers, timer, when);
2377 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2378 timer = malloc(sizeof(*timer));
2379 timer_init(timer);
2380 timer_addmono(&timers, timer, when);
2381 when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2382 timer = malloc(sizeof(*timer));
2383 timer_init(timer);
2384 timer_addmono(&timers, timer, when);
2385 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2386 timer = malloc(sizeof(*timer));
2387 timer_init(timer);
2388 timer_addmono(&timers, timer, when);
2389 timer_earliest(&timers, &when);
2390 free(timers_expire(&timers, when));
2391 when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000;
2392 timer = malloc(sizeof(*timer));
2393 timer_init(timer);
2394 timer_addmono(&timers, timer, when);
2395 when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000;
2396 timer = malloc(sizeof(*timer));
2397 timer_init(timer);
2398 timer_addmono(&timers, timer, when);
2399 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
2400 timer = malloc(sizeof(*timer));
2401 timer_init(timer);
2402 timer_addmono(&timers, timer, when);
2403 timer_earliest(&timers, &when);
2404 free(timers_expire(&timers, when));
2405 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2406 timer = malloc(sizeof(*timer));
2407 timer_init(timer);
2408 timer_addmono(&timers, timer, when);
2409 timer_earliest(&timers, &when);
2410 free(timers_expire(&timers, when));
2411 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2412 timer = malloc(sizeof(*timer));
2413 timer_init(timer);
2414 timer_addmono(&timers, timer, when);
2415 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
2416 timer = malloc(sizeof(*timer));
2417 timer_init(timer);
2418 timer_addmono(&timers, timer, when);
2419 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2420 timer = malloc(sizeof(*timer));
2421 timer_init(timer);
2422 timer_addmono(&timers, timer, when);
2423 timer_earliest(&timers, &when);
2424 free(timers_expire(&timers, when));
2425 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2426 timer = malloc(sizeof(*timer));
2427 timer_init(timer);
2428 timer_addmono(&timers, timer, when);
2429 when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
2430 timer = malloc(sizeof(*timer));
2431 timer_init(timer);
2432 timer_addmono(&timers, timer, when);
2433 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2434 timer = malloc(sizeof(*timer));
2435 timer_init(timer);
2436 timer_addmono(&timers, timer, when);
2437 timer_earliest(&timers, &when);
2438 free(timers_expire(&timers, when));
2439 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
2440 timer = malloc(sizeof(*timer));
2441 timer_init(timer);
2442 timer_addmono(&timers, timer, when);
2443 when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
2444 timer = malloc(sizeof(*timer));
2445 timer_init(timer);
2446 timer_addmono(&timers, timer, when);
2447 timer_earliest(&timers, &when);
2448 free(timers_expire(&timers, when));
2449 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2450 timer = malloc(sizeof(*timer));
2451 timer_init(timer);
2452 timer_addmono(&timers, timer, when);
2453 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
2454 timer = malloc(sizeof(*timer));
2455 timer_init(timer);
2456 timer_addmono(&timers, timer, when);
2457 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2458 timer = malloc(sizeof(*timer));
2459 timer_init(timer);
2460 timer_addmono(&timers, timer, when);
2461 timer_earliest(&timers, &when);
2462 free(timers_expire(&timers, when));
2463 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
2464 timer = malloc(sizeof(*timer));
2465 timer_init(timer);
2466 timer_addmono(&timers, timer, when);
2467 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2468 timer = malloc(sizeof(*timer));
2469 timer_init(timer);
2470 timer_addmono(&timers, timer, when);
2471 timer_earliest(&timers, &when);
2472 free(timers_expire(&timers, when));
2473 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
2474 timer = malloc(sizeof(*timer));
2475 timer_init(timer);
2476 timer_addmono(&timers, timer, when);
2477 timer_earliest(&timers, &when);
2478 free(timers_expire(&timers, when));
2479 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
2480 timer = malloc(sizeof(*timer));
2481 timer_init(timer);
2482 timer_addmono(&timers, timer, when);
2483 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2484 timer = malloc(sizeof(*timer));
2485 timer_init(timer);
2486 timer_addmono(&timers, timer, when);
2487 when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
2488 timer = malloc(sizeof(*timer));
2489 timer_init(timer);
2490 timer_addmono(&timers, timer, when);
2491 timer_earliest(&timers, &when);
2492 free(timers_expire(&timers, when));
2493 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2494 timer = malloc(sizeof(*timer));
2495 timer_init(timer);
2496 timer_addmono(&timers, timer, when);
2497 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2498 timer = malloc(sizeof(*timer));
2499 timer_init(timer);
2500 timer_addmono(&timers, timer, when);
2501 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
2502 timer = malloc(sizeof(*timer));
2503 timer_init(timer);
2504 timer_addmono(&timers, timer, when);
2505 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2506 timer = malloc(sizeof(*timer));
2507 timer_init(timer);
2508 timer_addmono(&timers, timer, when);
2509 timer_earliest(&timers, &when);
2510 free(timers_expire(&timers, when));
2511 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
2512 timer = malloc(sizeof(*timer));
2513 timer_init(timer);
2514 timer_addmono(&timers, timer, when);
2515 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2516 timer = malloc(sizeof(*timer));
2517 timer_init(timer);
2518 timer_addmono(&timers, timer, when);
2519 timer_earliest(&timers, &when);
2520 free(timers_expire(&timers, when));
2521 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
2522 timer = malloc(sizeof(*timer));
2523 timer_init(timer);
2524 timer_addmono(&timers, timer, when);
2525 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2526 timer = malloc(sizeof(*timer));
2527 timer_init(timer);
2528 timer_addmono(&timers, timer, when);
2529 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2530 timer = malloc(sizeof(*timer));
2531 timer_init(timer);
2532 timer_addmono(&timers, timer, when);
2533 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2534 timer = malloc(sizeof(*timer));
2535 timer_init(timer);
2536 timer_addmono(&timers, timer, when);
2537 when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
2538 timer = malloc(sizeof(*timer));
2539 timer_init(timer);
2540 timer_addmono(&timers, timer, when);
2541 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2542 timer = malloc(sizeof(*timer));
2543 timer_init(timer);
2544 timer_addmono(&timers, timer, when);
2545 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2546 timer = malloc(sizeof(*timer));
2547 timer_init(timer);
2548 timer_addmono(&timers, timer, when);
2549 timer_earliest(&timers, &when);
2550 free(timers_expire(&timers, when));
2551 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2552 timer = malloc(sizeof(*timer));
2553 timer_init(timer);
2554 timer_addmono(&timers, timer, when);
2555 timer_earliest(&timers, &when);
2556 free(timers_expire(&timers, when));
2557 when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000;
2558 timer = malloc(sizeof(*timer));
2559 timer_init(timer);
2560 timer_addmono(&timers, timer, when);
2561 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2562 timer = malloc(sizeof(*timer));
2563 timer_init(timer);
2564 timer_addmono(&timers, timer, when);
2565 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
2566 timer = malloc(sizeof(*timer));
2567 timer_init(timer);
2568 timer_addmono(&timers, timer, when);
2569 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
2570 timer = malloc(sizeof(*timer));
2571 timer_init(timer);
2572 timer_addmono(&timers, timer, when);
2573 timer_earliest(&timers, &when);
2574 free(timers_expire(&timers, when));
2575 timer_earliest(&timers, &when);
2576 free(timers_expire(&timers, when));
2577 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2578 timer = malloc(sizeof(*timer));
2579 timer_init(timer);
2580 timer_addmono(&timers, timer, when);
2581 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2582 timer = malloc(sizeof(*timer));
2583 timer_init(timer);
2584 timer_addmono(&timers, timer, when);
2585 when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
2586 timer = malloc(sizeof(*timer));
2587 timer_init(timer);
2588 timer_addmono(&timers, timer, when);
2589 timer_earliest(&timers, &when);
2590 free(timers_expire(&timers, when));
2591 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2592 timer = malloc(sizeof(*timer));
2593 timer_init(timer);
2594 timer_addmono(&timers, timer, when);
2595 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2596 timer = malloc(sizeof(*timer));
2597 timer_init(timer);
2598 timer_addmono(&timers, timer, when);
2599 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2600 timer = malloc(sizeof(*timer));
2601 timer_init(timer);
2602 timer_addmono(&timers, timer, when);
2603 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2604 timer = malloc(sizeof(*timer));
2605 timer_init(timer);
2606 timer_addmono(&timers, timer, when);
2607 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2608 timer = malloc(sizeof(*timer));
2609 timer_init(timer);
2610 timer_addmono(&timers, timer, when);
2611 timer_earliest(&timers, &when);
2612 free(timers_expire(&timers, when));
2613 timer_earliest(&timers, &when);
2614 free(timers_expire(&timers, when));
2615 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2616 timer = malloc(sizeof(*timer));
2617 timer_init(timer);
2618 timer_addmono(&timers, timer, when);
2619 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2620 timer = malloc(sizeof(*timer));
2621 timer_init(timer);
2622 timer_addmono(&timers, timer, when);
2623 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2624 timer = malloc(sizeof(*timer));
2625 timer_init(timer);
2626 timer_addmono(&timers, timer, when);
2627 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2628 timer = malloc(sizeof(*timer));
2629 timer_init(timer);
2630 timer_addmono(&timers, timer, when);
2631 timer_earliest(&timers, &when);
2632 free(timers_expire(&timers, when));
2633 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
2634 timer = malloc(sizeof(*timer));
2635 timer_init(timer);
2636 timer_addmono(&timers, timer, when);
2637 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
2638 timer = malloc(sizeof(*timer));
2639 timer_init(timer);
2640 timer_addmono(&timers, timer, when);
2641 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2642 timer = malloc(sizeof(*timer));
2643 timer_init(timer);
2644 timer_addmono(&timers, timer, when);
2645 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2646 timer = malloc(sizeof(*timer));
2647 timer_init(timer);
2648 timer_addmono(&timers, timer, when);
2649 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2650 timer = malloc(sizeof(*timer));
2651 timer_init(timer);
2652 timer_addmono(&timers, timer, when);
2653 timer_earliest(&timers, &when);
2654 free(timers_expire(&timers, when));
2655 timer_earliest(&timers, &when);
2656 free(timers_expire(&timers, when));
2657 timer_earliest(&timers, &when);
2658 free(timers_expire(&timers, when));
2659 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
2660 timer = malloc(sizeof(*timer));
2661 timer_init(timer);
2662 timer_addmono(&timers, timer, when);
2663 when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2664 timer = malloc(sizeof(*timer));
2665 timer_init(timer);
2666 timer_addmono(&timers, timer, when);
2667 timer_earliest(&timers, &when);
2668 free(timers_expire(&timers, when));
2669 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2670 timer = malloc(sizeof(*timer));
2671 timer_init(timer);
2672 timer_addmono(&timers, timer, when);
2673 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2674 timer = malloc(sizeof(*timer));
2675 timer_init(timer);
2676 timer_addmono(&timers, timer, when);
2677 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2678 timer = malloc(sizeof(*timer));
2679 timer_init(timer);
2680 timer_addmono(&timers, timer, when);
2681 timer_earliest(&timers, &when);
2682 free(timers_expire(&timers, when));
2683 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
2684 timer = malloc(sizeof(*timer));
2685 timer_init(timer);
2686 timer_addmono(&timers, timer, when);
2687 when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
2688 timer = malloc(sizeof(*timer));
2689 timer_init(timer);
2690 timer_addmono(&timers, timer, when);
2691 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2692 timer = malloc(sizeof(*timer));
2693 timer_init(timer);
2694 timer_addmono(&timers, timer, when);
2695 timer_earliest(&timers, &when);
2696 free(timers_expire(&timers, when));
2697 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2698 timer = malloc(sizeof(*timer));
2699 timer_init(timer);
2700 timer_addmono(&timers, timer, when);
2701 when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000;
2702 timer = malloc(sizeof(*timer));
2703 timer_init(timer);
2704 timer_addmono(&timers, timer, when);
2705 when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
2706 timer = malloc(sizeof(*timer));
2707 timer_init(timer);
2708 timer_addmono(&timers, timer, when);
2709 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
2710 timer = malloc(sizeof(*timer));
2711 timer_init(timer);
2712 timer_addmono(&timers, timer, when);
2713 timer_earliest(&timers, &when);
2714 free(timers_expire(&timers, when));
2715 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2716 timer = malloc(sizeof(*timer));
2717 timer_init(timer);
2718 timer_addmono(&timers, timer, when);
2719 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2720 timer = malloc(sizeof(*timer));
2721 timer_init(timer);
2722 timer_addmono(&timers, timer, when);
2723 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2724 timer = malloc(sizeof(*timer));
2725 timer_init(timer);
2726 timer_addmono(&timers, timer, when);
2727 timer_earliest(&timers, &when);
2728 free(timers_expire(&timers, when));
2729 timer_earliest(&timers, &when);
2730 free(timers_expire(&timers, when));
2731 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2732 timer = malloc(sizeof(*timer));
2733 timer_init(timer);
2734 timer_addmono(&timers, timer, when);
2735 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
2736 timer = malloc(sizeof(*timer));
2737 timer_init(timer);
2738 timer_addmono(&timers, timer, when);
2739 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2740 timer = malloc(sizeof(*timer));
2741 timer_init(timer);
2742 timer_addmono(&timers, timer, when);
2743 timer_earliest(&timers, &when);
2744 free(timers_expire(&timers, when));
2745 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2746 timer = malloc(sizeof(*timer));
2747 timer_init(timer);
2748 timer_addmono(&timers, timer, when);
2749 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
2750 timer = malloc(sizeof(*timer));
2751 timer_init(timer);
2752 timer_addmono(&timers, timer, when);
2753 timer_earliest(&timers, &when);
2754 free(timers_expire(&timers, when));
2755 timer_earliest(&timers, &when);
2756 free(timers_expire(&timers, when));
2757 timer_earliest(&timers, &when);
2758 free(timers_expire(&timers, when));
2759 timer_earliest(&timers, &when);
2760 free(timers_expire(&timers, when));
2761 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2762 timer = malloc(sizeof(*timer));
2763 timer_init(timer);
2764 timer_addmono(&timers, timer, when);
2765 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2766 timer = malloc(sizeof(*timer));
2767 timer_init(timer);
2768 timer_addmono(&timers, timer, when);
2769 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2770 timer = malloc(sizeof(*timer));
2771 timer_init(timer);
2772 timer_addmono(&timers, timer, when);
2773 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
2774 timer = malloc(sizeof(*timer));
2775 timer_init(timer);
2776 timer_addmono(&timers, timer, when);
2777 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
2778 timer = malloc(sizeof(*timer));
2779 timer_init(timer);
2780 timer_addmono(&timers, timer, when);
2781 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2782 timer = malloc(sizeof(*timer));
2783 timer_init(timer);
2784 timer_addmono(&timers, timer, when);
2785 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2786 timer = malloc(sizeof(*timer));
2787 timer_init(timer);
2788 timer_addmono(&timers, timer, when);
2789 timer_earliest(&timers, &when);
2790 free(timers_expire(&timers, when));
2791 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2792 timer = malloc(sizeof(*timer));
2793 timer_init(timer);
2794 timer_addmono(&timers, timer, when);
2795 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2796 timer = malloc(sizeof(*timer));
2797 timer_init(timer);
2798 timer_addmono(&timers, timer, when);
2799 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
2800 timer = malloc(sizeof(*timer));
2801 timer_init(timer);
2802 timer_addmono(&timers, timer, when);
2803 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2804 timer = malloc(sizeof(*timer));
2805 timer_init(timer);
2806 timer_addmono(&timers, timer, when);
2807 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
2808 timer = malloc(sizeof(*timer));
2809 timer_init(timer);
2810 timer_addmono(&timers, timer, when);
2811 timer_earliest(&timers, &when);
2812 free(timers_expire(&timers, when));
2813 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2814 timer = malloc(sizeof(*timer));
2815 timer_init(timer);
2816 timer_addmono(&timers, timer, when);
2817 timer_earliest(&timers, &when);
2818 free(timers_expire(&timers, when));
2819 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2820 timer = malloc(sizeof(*timer));
2821 timer_init(timer);
2822 timer_addmono(&timers, timer, when);
2823 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2824 timer = malloc(sizeof(*timer));
2825 timer_init(timer);
2826 timer_addmono(&timers, timer, when);
2827 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2828 timer = malloc(sizeof(*timer));
2829 timer_init(timer);
2830 timer_addmono(&timers, timer, when);
2831 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2832 timer = malloc(sizeof(*timer));
2833 timer_init(timer);
2834 timer_addmono(&timers, timer, when);
2835 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
2836 timer = malloc(sizeof(*timer));
2837 timer_init(timer);
2838 timer_addmono(&timers, timer, when);
2839 when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2840 timer = malloc(sizeof(*timer));
2841 timer_init(timer);
2842 timer_addmono(&timers, timer, when);
2843 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2844 timer = malloc(sizeof(*timer));
2845 timer_init(timer);
2846 timer_addmono(&timers, timer, when);
2847 timer_earliest(&timers, &when);
2848 free(timers_expire(&timers, when));
2849 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2850 timer = malloc(sizeof(*timer));
2851 timer_init(timer);
2852 timer_addmono(&timers, timer, when);
2853 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2854 timer = malloc(sizeof(*timer));
2855 timer_init(timer);
2856 timer_addmono(&timers, timer, when);
2857 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
2858 timer = malloc(sizeof(*timer));
2859 timer_init(timer);
2860 timer_addmono(&timers, timer, when);
2861 when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
2862 timer = malloc(sizeof(*timer));
2863 timer_init(timer);
2864 timer_addmono(&timers, timer, when);
2865 when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2866 timer = malloc(sizeof(*timer));
2867 timer_init(timer);
2868 timer_addmono(&timers, timer, when);
2869 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2870 timer = malloc(sizeof(*timer));
2871 timer_init(timer);
2872 timer_addmono(&timers, timer, when);
2873 timer_earliest(&timers, &when);
2874 free(timers_expire(&timers, when));
2875 timer_earliest(&timers, &when);
2876 free(timers_expire(&timers, when));
2877 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2878 timer = malloc(sizeof(*timer));
2879 timer_init(timer);
2880 timer_addmono(&timers, timer, when);
2881 timer_earliest(&timers, &when);
2882 free(timers_expire(&timers, when));
2883 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
2884 timer = malloc(sizeof(*timer));
2885 timer_init(timer);
2886 timer_addmono(&timers, timer, when);
2887 timer_earliest(&timers, &when);
2888 free(timers_expire(&timers, when));
2889 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
2890 timer = malloc(sizeof(*timer));
2891 timer_init(timer);
2892 timer_addmono(&timers, timer, when);
2893 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2894 timer = malloc(sizeof(*timer));
2895 timer_init(timer);
2896 timer_addmono(&timers, timer, when);
2897 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
2898 timer = malloc(sizeof(*timer));
2899 timer_init(timer);
2900 timer_addmono(&timers, timer, when);
2901 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2902 timer = malloc(sizeof(*timer));
2903 timer_init(timer);
2904 timer_addmono(&timers, timer, when);
2905 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
2906 timer = malloc(sizeof(*timer));
2907 timer_init(timer);
2908 timer_addmono(&timers, timer, when);
2909 timer_earliest(&timers, &when);
2910 free(timers_expire(&timers, when));
2911 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2912 timer = malloc(sizeof(*timer));
2913 timer_init(timer);
2914 timer_addmono(&timers, timer, when);
2915 timer_earliest(&timers, &when);
2916 free(timers_expire(&timers, when));
2917 when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
2918 timer = malloc(sizeof(*timer));
2919 timer_init(timer);
2920 timer_addmono(&timers, timer, when);
2921 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2922 timer = malloc(sizeof(*timer));
2923 timer_init(timer);
2924 timer_addmono(&timers, timer, when);
2925 when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000;
2926 timer = malloc(sizeof(*timer));
2927 timer_init(timer);
2928 timer_addmono(&timers, timer, when);
2929 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
2930 timer = malloc(sizeof(*timer));
2931 timer_init(timer);
2932 timer_addmono(&timers, timer, when);
2933 timer_earliest(&timers, &when);
2934 free(timers_expire(&timers, when));
2935 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2936 timer = malloc(sizeof(*timer));
2937 timer_init(timer);
2938 timer_addmono(&timers, timer, when);
2939 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2940 timer = malloc(sizeof(*timer));
2941 timer_init(timer);
2942 timer_addmono(&timers, timer, when);
2943 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2944 timer = malloc(sizeof(*timer));
2945 timer_init(timer);
2946 timer_addmono(&timers, timer, when);
2947 timer_earliest(&timers, &when);
2948 free(timers_expire(&timers, when));
2949 timer_earliest(&timers, &when);
2950 free(timers_expire(&timers, when));
2951 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2952 timer = malloc(sizeof(*timer));
2953 timer_init(timer);
2954 timer_addmono(&timers, timer, when);
2955 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2956 timer = malloc(sizeof(*timer));
2957 timer_init(timer);
2958 timer_addmono(&timers, timer, when);
2959 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2960 timer = malloc(sizeof(*timer));
2961 timer_init(timer);
2962 timer_addmono(&timers, timer, when);
2963 when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2964 timer = malloc(sizeof(*timer));
2965 timer_init(timer);
2966 timer_addmono(&timers, timer, when);
2967 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2968 timer = malloc(sizeof(*timer));
2969 timer_init(timer);
2970 timer_addmono(&timers, timer, when);
2971 timer_earliest(&timers, &when);
2972 free(timers_expire(&timers, when));
2973 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
2974 timer = malloc(sizeof(*timer));
2975 timer_init(timer);
2976 timer_addmono(&timers, timer, when);
2977 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2978 timer = malloc(sizeof(*timer));
2979 timer_init(timer);
2980 timer_addmono(&timers, timer, when);
2981 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
2982 timer = malloc(sizeof(*timer));
2983 timer_init(timer);
2984 timer_addmono(&timers, timer, when);
2985 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
2986 timer = malloc(sizeof(*timer));
2987 timer_init(timer);
2988 timer_addmono(&timers, timer, when);
2989 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2990 timer = malloc(sizeof(*timer));
2991 timer_init(timer);
2992 timer_addmono(&timers, timer, when);
2993 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2994 timer = malloc(sizeof(*timer));
2995 timer_init(timer);
2996 timer_addmono(&timers, timer, when);
2997 timer_earliest(&timers, &when);
2998 free(timers_expire(&timers, when));
2999 timer_earliest(&timers, &when);
3000 free(timers_expire(&timers, when));
3001 timer_earliest(&timers, &when);
3002 free(timers_expire(&timers, when));
3003 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3004 timer = malloc(sizeof(*timer));
3005 timer_init(timer);
3006 timer_addmono(&timers, timer, when);
3007 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3008 timer = malloc(sizeof(*timer));
3009 timer_init(timer);
3010 timer_addmono(&timers, timer, when);
3011 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3012 timer = malloc(sizeof(*timer));
3013 timer_init(timer);
3014 timer_addmono(&timers, timer, when);
3015 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3016 timer = malloc(sizeof(*timer));
3017 timer_init(timer);
3018 timer_addmono(&timers, timer, when);
3019 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3020 timer = malloc(sizeof(*timer));
3021 timer_init(timer);
3022 timer_addmono(&timers, timer, when);
3023 when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
3024 timer = malloc(sizeof(*timer));
3025 timer_init(timer);
3026 timer_addmono(&timers, timer, when);
3027 when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
3028 timer = malloc(sizeof(*timer));
3029 timer_init(timer);
3030 timer_addmono(&timers, timer, when);
3031 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3032 timer = malloc(sizeof(*timer));
3033 timer_init(timer);
3034 timer_addmono(&timers, timer, when);
3035 timer_earliest(&timers, &when);
3036 free(timers_expire(&timers, when));
3037 timer_earliest(&timers, &when);
3038 free(timers_expire(&timers, when));
3039 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3040 timer = malloc(sizeof(*timer));
3041 timer_init(timer);
3042 timer_addmono(&timers, timer, when);
3043 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3044 timer = malloc(sizeof(*timer));
3045 timer_init(timer);
3046 timer_addmono(&timers, timer, when);
3047 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3048 timer = malloc(sizeof(*timer));
3049 timer_init(timer);
3050 timer_addmono(&timers, timer, when);
3051 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3052 timer = malloc(sizeof(*timer));
3053 timer_init(timer);
3054 timer_addmono(&timers, timer, when);
3055 timer_earliest(&timers, &when);
3056 free(timers_expire(&timers, when));
3057 timer_earliest(&timers, &when);
3058 free(timers_expire(&timers, when));
3059 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3060 timer = malloc(sizeof(*timer));
3061 timer_init(timer);
3062 timer_addmono(&timers, timer, when);
3063 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
3064 timer = malloc(sizeof(*timer));
3065 timer_init(timer);
3066 timer_addmono(&timers, timer, when);
3067 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3068 timer = malloc(sizeof(*timer));
3069 timer_init(timer);
3070 timer_addmono(&timers, timer, when);
3071 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3072 timer = malloc(sizeof(*timer));
3073 timer_init(timer);
3074 timer_addmono(&timers, timer, when);
3075 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3076 timer = malloc(sizeof(*timer));
3077 timer_init(timer);
3078 timer_addmono(&timers, timer, when);
3079 timer_earliest(&timers, &when);
3080 free(timers_expire(&timers, when));
3081 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3082 timer = malloc(sizeof(*timer));
3083 timer_init(timer);
3084 timer_addmono(&timers, timer, when);
3085 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3086 timer = malloc(sizeof(*timer));
3087 timer_init(timer);
3088 timer_addmono(&timers, timer, when);
3089 timer_earliest(&timers, &when);
3090 free(timers_expire(&timers, when));
3091 timer_earliest(&timers, &when);
3092 free(timers_expire(&timers, when));
3093 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3094 timer = malloc(sizeof(*timer));
3095 timer_init(timer);
3096 timer_addmono(&timers, timer, when);
3097 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
3098 timer = malloc(sizeof(*timer));
3099 timer_init(timer);
3100 timer_addmono(&timers, timer, when);
3101 timer_earliest(&timers, &when);
3102 free(timers_expire(&timers, when));
3103 timer_earliest(&timers, &when);
3104 free(timers_expire(&timers, when));
3105 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
3106 timer = malloc(sizeof(*timer));
3107 timer_init(timer);
3108 timer_addmono(&timers, timer, when);
3109 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3110 timer = malloc(sizeof(*timer));
3111 timer_init(timer);
3112 timer_addmono(&timers, timer, when);
3113 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
3114 timer = malloc(sizeof(*timer));
3115 timer_init(timer);
3116 timer_addmono(&timers, timer, when);
3117 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3118 timer = malloc(sizeof(*timer));
3119 timer_init(timer);
3120 timer_addmono(&timers, timer, when);
3121 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3122 timer = malloc(sizeof(*timer));
3123 timer_init(timer);
3124 timer_addmono(&timers, timer, when);
3125 timer_earliest(&timers, &when);
3126 free(timers_expire(&timers, when));
3127 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3128 timer = malloc(sizeof(*timer));
3129 timer_init(timer);
3130 timer_addmono(&timers, timer, when);
3131 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3132 timer = malloc(sizeof(*timer));
3133 timer_init(timer);
3134 timer_addmono(&timers, timer, when);
3135 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3136 timer = malloc(sizeof(*timer));
3137 timer_init(timer);
3138 timer_addmono(&timers, timer, when);
3139 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3140 timer = malloc(sizeof(*timer));
3141 timer_init(timer);
3142 timer_addmono(&timers, timer, when);
3143 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
3144 timer = malloc(sizeof(*timer));
3145 timer_init(timer);
3146 timer_addmono(&timers, timer, when);
3147 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3148 timer = malloc(sizeof(*timer));
3149 timer_init(timer);
3150 timer_addmono(&timers, timer, when);
3151 when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
3152 timer = malloc(sizeof(*timer));
3153 timer_init(timer);
3154 timer_addmono(&timers, timer, when);
3155 timer_earliest(&timers, &when);
3156 free(timers_expire(&timers, when));
3157 timer_earliest(&timers, &when);
3158 free(timers_expire(&timers, when));
3159 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3160 timer = malloc(sizeof(*timer));
3161 timer_init(timer);
3162 timer_addmono(&timers, timer, when);
3163 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
3164 timer = malloc(sizeof(*timer));
3165 timer_init(timer);
3166 timer_addmono(&timers, timer, when);
3167 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3168 timer = malloc(sizeof(*timer));
3169 timer_init(timer);
3170 timer_addmono(&timers, timer, when);
3171 timer_earliest(&timers, &when);
3172 free(timers_expire(&timers, when));
3173 timer_earliest(&timers, &when);
3174 free(timers_expire(&timers, when));
3175 timer_earliest(&timers, &when);
3176 free(timers_expire(&timers, when));
3177 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3178 timer = malloc(sizeof(*timer));
3179 timer_init(timer);
3180 timer_addmono(&timers, timer, when);
3181 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3182 timer = malloc(sizeof(*timer));
3183 timer_init(timer);
3184 timer_addmono(&timers, timer, when);
3185 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
3186 timer = malloc(sizeof(*timer));
3187 timer_init(timer);
3188 timer_addmono(&timers, timer, when);
3189 timer_earliest(&timers, &when);
3190 free(timers_expire(&timers, when));
3191 timer_earliest(&timers, &when);
3192 free(timers_expire(&timers, when));
3193 timer_earliest(&timers, &when);
3194 free(timers_expire(&timers, when));
3195 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
3196 timer = malloc(sizeof(*timer));
3197 timer_init(timer);
3198 timer_addmono(&timers, timer, when);
3199 when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
3200 timer = malloc(sizeof(*timer));
3201 timer_init(timer);
3202 timer_addmono(&timers, timer, when);
3203 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3204 timer = malloc(sizeof(*timer));
3205 timer_init(timer);
3206 timer_addmono(&timers, timer, when);
3207 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3208 timer = malloc(sizeof(*timer));
3209 timer_init(timer);
3210 timer_addmono(&timers, timer, when);
3211 when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
3212 timer = malloc(sizeof(*timer));
3213 timer_init(timer);
3214 timer_addmono(&timers, timer, when);
3215 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3216 timer = malloc(sizeof(*timer));
3217 timer_init(timer);
3218 timer_addmono(&timers, timer, when);
3219 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3220 timer = malloc(sizeof(*timer));
3221 timer_init(timer);
3222 timer_addmono(&timers, timer, when);
3223 timer_earliest(&timers, &when);
3224 free(timers_expire(&timers, when));
3225 timer_earliest(&timers, &when);
3226 free(timers_expire(&timers, when));
3227 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3228 timer = malloc(sizeof(*timer));
3229 timer_init(timer);
3230 timer_addmono(&timers, timer, when);
3231 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3232 timer = malloc(sizeof(*timer));
3233 timer_init(timer);
3234 timer_addmono(&timers, timer, when);
3235 when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
3236 timer = malloc(sizeof(*timer));
3237 timer_init(timer);
3238 timer_addmono(&timers, timer, when);
3239 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3240 timer = malloc(sizeof(*timer));
3241 timer_init(timer);
3242 timer_addmono(&timers, timer, when);
3243 timer_earliest(&timers, &when);
3244 free(timers_expire(&timers, when));
3245 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
3246 timer = malloc(sizeof(*timer));
3247 timer_init(timer);
3248 timer_addmono(&timers, timer, when);
3249 timer_earliest(&timers, &when);
3250 free(timers_expire(&timers, when));
3251 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
3252 timer = malloc(sizeof(*timer));
3253 timer_init(timer);
3254 timer_addmono(&timers, timer, when);
3255 timer_earliest(&timers, &when);
3256 free(timers_expire(&timers, when));
3257 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
3258 timer = malloc(sizeof(*timer));
3259 timer_init(timer);
3260 timer_addmono(&timers, timer, when);
3261 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3262 timer = malloc(sizeof(*timer));
3263 timer_init(timer);
3264 timer_addmono(&timers, timer, when);
3265 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3266 timer = malloc(sizeof(*timer));
3267 timer_init(timer);
3268 timer_addmono(&timers, timer, when);
3269 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3270 timer = malloc(sizeof(*timer));
3271 timer_init(timer);
3272 timer_addmono(&timers, timer, when);
3273 timer_earliest(&timers, &when);
3274 free(timers_expire(&timers, when));
3275 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
3276 timer = malloc(sizeof(*timer));
3277 timer_init(timer);
3278 timer_addmono(&timers, timer, when);
3279 when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
3280 timer = malloc(sizeof(*timer));
3281 timer_init(timer);
3282 timer_addmono(&timers, timer, when);
3283 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3284 timer = malloc(sizeof(*timer));
3285 timer_init(timer);
3286 timer_addmono(&timers, timer, when);
3287 timer_earliest(&timers, &when);
3288 free(timers_expire(&timers, when));
3289 timer_earliest(&timers, &when);
3290 free(timers_expire(&timers, when));
3291 timer_earliest(&timers, &when);
3292 free(timers_expire(&timers, when));
3293 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3294 timer = malloc(sizeof(*timer));
3295 timer_init(timer);
3296 timer_addmono(&timers, timer, when);
3297 timer_earliest(&timers, &when);
3298 free(timers_expire(&timers, when));
3299 timer_earliest(&timers, &when);
3300 free(timers_expire(&timers, when));
3301 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
3302 timer = malloc(sizeof(*timer));
3303 timer_init(timer);
3304 timer_addmono(&timers, timer, when);
3305 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3306 timer = malloc(sizeof(*timer));
3307 timer_init(timer);
3308 timer_addmono(&timers, timer, when);
3309 when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000;
3310 timer = malloc(sizeof(*timer));
3311 timer_init(timer);
3312 timer_addmono(&timers, timer, when);
3313 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
3314 timer = malloc(sizeof(*timer));
3315 timer_init(timer);
3316 timer_addmono(&timers, timer, when);
3317 timer_earliest(&timers, &when);
3318 free(timers_expire(&timers, when));
3319 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
3320 timer = malloc(sizeof(*timer));
3321 timer_init(timer);
3322 timer_addmono(&timers, timer, when);
3323 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3324 timer = malloc(sizeof(*timer));
3325 timer_init(timer);
3326 timer_addmono(&timers, timer, when);
3327 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
3328 timer = malloc(sizeof(*timer));
3329 timer_init(timer);
3330 timer_addmono(&timers, timer, when);
3331 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3332 timer = malloc(sizeof(*timer));
3333 timer_init(timer);
3334 timer_addmono(&timers, timer, when);
3335 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3336 timer = malloc(sizeof(*timer));
3337 timer_init(timer);
3338 timer_addmono(&timers, timer, when);
3339 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
3340 timer = malloc(sizeof(*timer));
3341 timer_init(timer);
3342 timer_addmono(&timers, timer, when);
3343 when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
3344 timer = malloc(sizeof(*timer));
3345 timer_init(timer);
3346 timer_addmono(&timers, timer, when);
3347 timer_earliest(&timers, &when);
3348 free(timers_expire(&timers, when));
3349 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3350 timer = malloc(sizeof(*timer));
3351 timer_init(timer);
3352 timer_addmono(&timers, timer, when);
3353 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3354 timer = malloc(sizeof(*timer));
3355 timer_init(timer);
3356 timer_addmono(&timers, timer, when);
3357 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3358 timer = malloc(sizeof(*timer));
3359 timer_init(timer);
3360 timer_addmono(&timers, timer, when);
3361 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3362 timer = malloc(sizeof(*timer));
3363 timer_init(timer);
3364 timer_addmono(&timers, timer, when);
3365 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3366 timer = malloc(sizeof(*timer));
3367 timer_init(timer);
3368 timer_addmono(&timers, timer, when);
3369 when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
3370 timer = malloc(sizeof(*timer));
3371 timer_init(timer);
3372 timer_addmono(&timers, timer, when);
3373 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
3374 timer = malloc(sizeof(*timer));
3375 timer_init(timer);
3376 timer_addmono(&timers, timer, when);
3377 timer_earliest(&timers, &when);
3378 free(timers_expire(&timers, when));
3379 timer_earliest(&timers, &when);
3380 free(timers_expire(&timers, when));
3381 timer_earliest(&timers, &when);
3382 free(timers_expire(&timers, when));
3383 when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
3384 timer = malloc(sizeof(*timer));
3385 timer_init(timer);
3386 timer_addmono(&timers, timer, when);
3387 timer_earliest(&timers, &when);
3388 free(timers_expire(&timers, when));
3389 timer_earliest(&timers, &when);
3390 free(timers_expire(&timers, when));
3391 timer_earliest(&timers, &when);
3392 free(timers_expire(&timers, when));
3393 timer_earliest(&timers, &when);
3394 free(timers_expire(&timers, when));
3395 timer_earliest(&timers, &when);
3396 free(timers_expire(&timers, when));
3397 timer_earliest(&timers, &when);
3398 free(timers_expire(&timers, when));
3399 timer_earliest(&timers, &when);
3400 free(timers_expire(&timers, when));
3401 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
3402 timer = malloc(sizeof(*timer));
3403 timer_init(timer);
3404 timer_addmono(&timers, timer, when);
3405 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
3406 timer = malloc(sizeof(*timer));
3407 timer_init(timer);
3408 timer_addmono(&timers, timer, when);
3409 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3410 timer = malloc(sizeof(*timer));
3411 timer_init(timer);
3412 timer_addmono(&timers, timer, when);
3413 timer_earliest(&timers, &when);
3414 free(timers_expire(&timers, when));
3415 timer_earliest(&timers, &when);
3416 free(timers_expire(&timers, when));
3417 timer_earliest(&timers, &when);
3418 free(timers_expire(&timers, when));
3419 timer_earliest(&timers, &when);
3420 free(timers_expire(&timers, when));
3421 timer_earliest(&timers, &when);
3422 free(timers_expire(&timers, when));
3423 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3424 timer = malloc(sizeof(*timer));
3425 timer_init(timer);
3426 timer_addmono(&timers, timer, when);
3427 when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000;
3428 timer = malloc(sizeof(*timer));
3429 timer_init(timer);
3430 timer_addmono(&timers, timer, when);
3431 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3432 timer = malloc(sizeof(*timer));
3433 timer_init(timer);
3434 timer_addmono(&timers, timer, when);
3435 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3436 timer = malloc(sizeof(*timer));
3437 timer_init(timer);
3438 timer_addmono(&timers, timer, when);
3439 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3440 timer = malloc(sizeof(*timer));
3441 timer_init(timer);
3442 timer_addmono(&timers, timer, when);
3443 timer_earliest(&timers, &when);
3444 free(timers_expire(&timers, when));
3445 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3446 timer = malloc(sizeof(*timer));
3447 timer_init(timer);
3448 timer_addmono(&timers, timer, when);
3449 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
3450 timer = malloc(sizeof(*timer));
3451 timer_init(timer);
3452 timer_addmono(&timers, timer, when);
3453 timer_earliest(&timers, &when);
3454 free(timers_expire(&timers, when));
3455 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
3456 timer = malloc(sizeof(*timer));
3457 timer_init(timer);
3458 timer_addmono(&timers, timer, when);
3459 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
3460 timer = malloc(sizeof(*timer));
3461 timer_init(timer);
3462 timer_addmono(&timers, timer, when);
3463 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
3464 timer = malloc(sizeof(*timer));
3465 timer_init(timer);
3466 timer_addmono(&timers, timer, when);
3467 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3468 timer = malloc(sizeof(*timer));
3469 timer_init(timer);
3470 timer_addmono(&timers, timer, when);
3471 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3472 timer = malloc(sizeof(*timer));
3473 timer_init(timer);
3474 timer_addmono(&timers, timer, when);
3475 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3476 timer = malloc(sizeof(*timer));
3477 timer_init(timer);
3478 timer_addmono(&timers, timer, when);
3479 timer_earliest(&timers, &when);
3480 free(timers_expire(&timers, when));
3481 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3482 timer = malloc(sizeof(*timer));
3483 timer_init(timer);
3484 timer_addmono(&timers, timer, when);
3485 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
3486 timer = malloc(sizeof(*timer));
3487 timer_init(timer);
3488 timer_addmono(&timers, timer, when);
3489 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
3490 timer = malloc(sizeof(*timer));
3491 timer_init(timer);
3492 timer_addmono(&timers, timer, when);
3493 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3494 timer = malloc(sizeof(*timer));
3495 timer_init(timer);
3496 timer_addmono(&timers, timer, when);
3497 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
3498 timer = malloc(sizeof(*timer));
3499 timer_init(timer);
3500 timer_addmono(&timers, timer, when);
3501 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3502 timer = malloc(sizeof(*timer));
3503 timer_init(timer);
3504 timer_addmono(&timers, timer, when);
3505 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
3506 timer = malloc(sizeof(*timer));
3507 timer_init(timer);
3508 timer_addmono(&timers, timer, when);
3509 timer_earliest(&timers, &when);
3510 free(timers_expire(&timers, when));
3511 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
3512 timer = malloc(sizeof(*timer));
3513 timer_init(timer);
3514 timer_addmono(&timers, timer, when);
3515 when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
3516 timer = malloc(sizeof(*timer));
3517 timer_init(timer);
3518 timer_addmono(&timers, timer, when);
3519 timer_earliest(&timers, &when);
3520 free(timers_expire(&timers, when));
3521 timer_earliest(&timers, &when);
3522 free(timers_expire(&timers, when));
3523 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
3524 timer = malloc(sizeof(*timer));
3525 timer_init(timer);
3526 timer_addmono(&timers, timer, when);
3527 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3528 timer = malloc(sizeof(*timer));
3529 timer_init(timer);
3530 timer_addmono(&timers, timer, when);
3531 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
3532 timer = malloc(sizeof(*timer));
3533 timer_init(timer);
3534 timer_addmono(&timers, timer, when);
3535 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3536 timer = malloc(sizeof(*timer));
3537 timer_init(timer);
3538 timer_addmono(&timers, timer, when);
3539 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
3540 timer = malloc(sizeof(*timer));
3541 timer_init(timer);
3542 timer_addmono(&timers, timer, when);
3543 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
3544 timer = malloc(sizeof(*timer));
3545 timer_init(timer);
3546 timer_addmono(&timers, timer, when);
3547 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3548 timer = malloc(sizeof(*timer));
3549 timer_init(timer);
3550 timer_addmono(&timers, timer, when);
3551 timer_earliest(&timers, &when);
3552 free(timers_expire(&timers, when));
3553 timer_earliest(&timers, &when);
3554 free(timers_expire(&timers, when));
3555 timer_earliest(&timers, &when);
3556 free(timers_expire(&timers, when));
3557 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
3558 timer = malloc(sizeof(*timer));
3559 timer_init(timer);
3560 timer_addmono(&timers, timer, when);
3561 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3562 timer = malloc(sizeof(*timer));
3563 timer_init(timer);
3564 timer_addmono(&timers, timer, when);
3565 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
3566 timer = malloc(sizeof(*timer));
3567 timer_init(timer);
3568 timer_addmono(&timers, timer, when);
3569 timer_earliest(&timers, &when);
3570 free(timers_expire(&timers, when));
3571 timer_earliest(&timers, &when);
3572 free(timers_expire(&timers, when));
3573 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3574 timer = malloc(sizeof(*timer));
3575 timer_init(timer);
3576 timer_addmono(&timers, timer, when);
3577 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3578 timer = malloc(sizeof(*timer));
3579 timer_init(timer);
3580 timer_addmono(&timers, timer, when);
3581 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3582 timer = malloc(sizeof(*timer));
3583 timer_init(timer);
3584 timer_addmono(&timers, timer, when);
3585 timer_earliest(&timers, &when);
3586 free(timers_expire(&timers, when));
3587 timer_earliest(&timers, &when);
3588 free(timers_expire(&timers, when));
3589 timer_earliest(&timers, &when);
3590 free(timers_expire(&timers, when));
3591 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3592 timer = malloc(sizeof(*timer));
3593 timer_init(timer);
3594 timer_addmono(&timers, timer, when);
3595 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
3596 timer = malloc(sizeof(*timer));
3597 timer_init(timer);
3598 timer_addmono(&timers, timer, when);
3599 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3600 timer = malloc(sizeof(*timer));
3601 timer_init(timer);
3602 timer_addmono(&timers, timer, when);
3603 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
3604 timer = malloc(sizeof(*timer));
3605 timer_init(timer);
3606 timer_addmono(&timers, timer, when);
3607 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3608 timer = malloc(sizeof(*timer));
3609 timer_init(timer);
3610 timer_addmono(&timers, timer, when);
3611 timer_earliest(&timers, &when);
3612 free(timers_expire(&timers, when));
3613 timer_earliest(&timers, &when);
3614 free(timers_expire(&timers, when));
3615 timer_earliest(&timers, &when);
3616 free(timers_expire(&timers, when));
3617 timer_earliest(&timers, &when);
3618 free(timers_expire(&timers, when));
3619 timer_earliest(&timers, &when);
3620 free(timers_expire(&timers, when));
3621 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3622 timer = malloc(sizeof(*timer));
3623 timer_init(timer);
3624 timer_addmono(&timers, timer, when);
3625 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
3626 timer = malloc(sizeof(*timer));
3627 timer_init(timer);
3628 timer_addmono(&timers, timer, when);
3629 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3630 timer = malloc(sizeof(*timer));
3631 timer_init(timer);
3632 timer_addmono(&timers, timer, when);
3633 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
3634 timer = malloc(sizeof(*timer));
3635 timer_init(timer);
3636 timer_addmono(&timers, timer, when);
3637 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
3638 timer = malloc(sizeof(*timer));
3639 timer_init(timer);
3640 timer_addmono(&timers, timer, when);
3641 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3642 timer = malloc(sizeof(*timer));
3643 timer_init(timer);
3644 timer_addmono(&timers, timer, when);
3645 timer_earliest(&timers, &when);
3646 free(timers_expire(&timers, when));
3647 timer_earliest(&timers, &when);
3648 free(timers_expire(&timers, when));
3649 timer_earliest(&timers, &when);
3650 free(timers_expire(&timers, when));
3651 timer_earliest(&timers, &when);
3652 free(timers_expire(&timers, when));
3653 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3654 timer = malloc(sizeof(*timer));
3655 timer_init(timer);
3656 timer_addmono(&timers, timer, when);
3657 timer_earliest(&timers, &when);
3658 free(timers_expire(&timers, when));
3659 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3660 timer = malloc(sizeof(*timer));
3661 timer_init(timer);
3662 timer_addmono(&timers, timer, when);
3663 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3664 timer = malloc(sizeof(*timer));
3665 timer_init(timer);
3666 timer_addmono(&timers, timer, when);
3667 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3668 timer = malloc(sizeof(*timer));
3669 timer_init(timer);
3670 timer_addmono(&timers, timer, when);
3671 timer_earliest(&timers, &when);
3672 free(timers_expire(&timers, when));
3673 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3674 timer = malloc(sizeof(*timer));
3675 timer_init(timer);
3676 timer_addmono(&timers, timer, when);
3677 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3678 timer = malloc(sizeof(*timer));
3679 timer_init(timer);
3680 timer_addmono(&timers, timer, when);
3681 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
3682 timer = malloc(sizeof(*timer));
3683 timer_init(timer);
3684 timer_addmono(&timers, timer, when);
3685 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3686 timer = malloc(sizeof(*timer));
3687 timer_init(timer);
3688 timer_addmono(&timers, timer, when);
3689 timer_earliest(&timers, &when);
3690 free(timers_expire(&timers, when));
3691 timer_earliest(&timers, &when);
3692 free(timers_expire(&timers, when));
3693 timer_earliest(&timers, &when);
3694 free(timers_expire(&timers, when));
3695 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
3696 timer = malloc(sizeof(*timer));
3697 timer_init(timer);
3698 timer_addmono(&timers, timer, when);
3699 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
3700 timer = malloc(sizeof(*timer));
3701 timer_init(timer);
3702 timer_addmono(&timers, timer, when);
3703 timer_earliest(&timers, &when);
3704 free(timers_expire(&timers, when));
3705 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3706 timer = malloc(sizeof(*timer));
3707 timer_init(timer);
3708 timer_addmono(&timers, timer, when);
3709 timer_earliest(&timers, &when);
3710 free(timers_expire(&timers, when));
3711 timer_earliest(&timers, &when);
3712 free(timers_expire(&timers, when));
3713 timer_earliest(&timers, &when);
3714 free(timers_expire(&timers, when));
3715 timer_earliest(&timers, &when);
3716 free(timers_expire(&timers, when));
3717 timer_earliest(&timers, &when);
3718 free(timers_expire(&timers, when));
3719 timer_earliest(&timers, &when);
3720 free(timers_expire(&timers, when));
3721 timer_earliest(&timers, &when);
3722 free(timers_expire(&timers, when));
3723 timer_earliest(&timers, &when);
3724 free(timers_expire(&timers, when));
3725 timer_earliest(&timers, &when);
3726 free(timers_expire(&timers, when));
3727 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
3728 timer = malloc(sizeof(*timer));
3729 timer_init(timer);
3730 timer_addmono(&timers, timer, when);
3731 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3732 timer = malloc(sizeof(*timer));
3733 timer_init(timer);
3734 timer_addmono(&timers, timer, when);
3735 timer_earliest(&timers, &when);
3736 free(timers_expire(&timers, when));
3737 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3738 timer = malloc(sizeof(*timer));
3739 timer_init(timer);
3740 timer_addmono(&timers, timer, when);
3741 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
3742 timer = malloc(sizeof(*timer));
3743 timer_init(timer);
3744 timer_addmono(&timers, timer, when);
3745 timer_earliest(&timers, &when);
3746 free(timers_expire(&timers, when));
3747 timer_earliest(&timers, &when);
3748 free(timers_expire(&timers, when));
3749 timer_earliest(&timers, &when);
3750 free(timers_expire(&timers, when));
3751 timer_earliest(&timers, &when);
3752 free(timers_expire(&timers, when));
3753 timer_earliest(&timers, &when);
3754 free(timers_expire(&timers, when));
3755 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
3756 timer = malloc(sizeof(*timer));
3757 timer_init(timer);
3758 timer_addmono(&timers, timer, when);
3759 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
3760 timer = malloc(sizeof(*timer));
3761 timer_init(timer);
3762 timer_addmono(&timers, timer, when);
3763 timer_earliest(&timers, &when);
3764 free(timers_expire(&timers, when));
3765 timer_earliest(&timers, &when);
3766 free(timers_expire(&timers, when));
3767 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3768 timer = malloc(sizeof(*timer));
3769 timer_init(timer);
3770 timer_addmono(&timers, timer, when);
3771 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3772 timer = malloc(sizeof(*timer));
3773 timer_init(timer);
3774 timer_addmono(&timers, timer, when);
3775 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3776 timer = malloc(sizeof(*timer));
3777 timer_init(timer);
3778 timer_addmono(&timers, timer, when);
3779 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
3780 timer = malloc(sizeof(*timer));
3781 timer_init(timer);
3782 timer_addmono(&timers, timer, when);
3783 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3784 timer = malloc(sizeof(*timer));
3785 timer_init(timer);
3786 timer_addmono(&timers, timer, when);
3787 timer_earliest(&timers, &when);
3788 free(timers_expire(&timers, when));
3789 timer_earliest(&timers, &when);
3790 free(timers_expire(&timers, when));
3791 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3792 timer = malloc(sizeof(*timer));
3793 timer_init(timer);
3794 timer_addmono(&timers, timer, when);
3795 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3796 timer = malloc(sizeof(*timer));
3797 timer_init(timer);
3798 timer_addmono(&timers, timer, when);
3799 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3800 timer = malloc(sizeof(*timer));
3801 timer_init(timer);
3802 timer_addmono(&timers, timer, when);
3803 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3804 timer = malloc(sizeof(*timer));
3805 timer_init(timer);
3806 timer_addmono(&timers, timer, when);
3807 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3808 timer = malloc(sizeof(*timer));
3809 timer_init(timer);
3810 timer_addmono(&timers, timer, when);
3811 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3812 timer = malloc(sizeof(*timer));
3813 timer_init(timer);
3814 timer_addmono(&timers, timer, when);
3815 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3816 timer = malloc(sizeof(*timer));
3817 timer_init(timer);
3818 timer_addmono(&timers, timer, when);
3819 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
3820 timer = malloc(sizeof(*timer));
3821 timer_init(timer);
3822 timer_addmono(&timers, timer, when);
3823 timer_earliest(&timers, &when);
3824 free(timers_expire(&timers, when));
3825 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3826 timer = malloc(sizeof(*timer));
3827 timer_init(timer);
3828 timer_addmono(&timers, timer, when);
3829 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
3830 timer = malloc(sizeof(*timer));
3831 timer_init(timer);
3832 timer_addmono(&timers, timer, when);
3833 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3834 timer = malloc(sizeof(*timer));
3835 timer_init(timer);
3836 timer_addmono(&timers, timer, when);
3837 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
3838 timer = malloc(sizeof(*timer));
3839 timer_init(timer);
3840 timer_addmono(&timers, timer, when);
3841 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
3842 timer = malloc(sizeof(*timer));
3843 timer_init(timer);
3844 timer_addmono(&timers, timer, when);
3845 timer_earliest(&timers, &when);
3846 free(timers_expire(&timers, when));
3847 timer_earliest(&timers, &when);
3848 free(timers_expire(&timers, when));
3849 timer_earliest(&timers, &when);
3850 free(timers_expire(&timers, when));
3851 timer_earliest(&timers, &when);
3852 free(timers_expire(&timers, when));
3853 timer_earliest(&timers, &when);
3854 free(timers_expire(&timers, when));
3855 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
3856 timer = malloc(sizeof(*timer));
3857 timer_init(timer);
3858 timer_addmono(&timers, timer, when);
3859 when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
3860 timer = malloc(sizeof(*timer));
3861 timer_init(timer);
3862 timer_addmono(&timers, timer, when);
3863 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
3864 timer = malloc(sizeof(*timer));
3865 timer_init(timer);
3866 timer_addmono(&timers, timer, when);
3867 timer_earliest(&timers, &when);
3868 free(timers_expire(&timers, when));
3869 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
3870 timer = malloc(sizeof(*timer));
3871 timer_init(timer);
3872 timer_addmono(&timers, timer, when);
3873 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3874 timer = malloc(sizeof(*timer));
3875 timer_init(timer);
3876 timer_addmono(&timers, timer, when);
3877 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
3878 timer = malloc(sizeof(*timer));
3879 timer_init(timer);
3880 timer_addmono(&timers, timer, when);
3881 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3882 timer = malloc(sizeof(*timer));
3883 timer_init(timer);
3884 timer_addmono(&timers, timer, when);
3885 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3886 timer = malloc(sizeof(*timer));
3887 timer_init(timer);
3888 timer_addmono(&timers, timer, when);
3889 timer_earliest(&timers, &when);
3890 free(timers_expire(&timers, when));
3891 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
3892 timer = malloc(sizeof(*timer));
3893 timer_init(timer);
3894 timer_addmono(&timers, timer, when);
3895 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3896 timer = malloc(sizeof(*timer));
3897 timer_init(timer);
3898 timer_addmono(&timers, timer, when);
3899 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3900 timer = malloc(sizeof(*timer));
3901 timer_init(timer);
3902 timer_addmono(&timers, timer, when);
3903 timer_earliest(&timers, &when);
3904 free(timers_expire(&timers, when));
3905 timer_earliest(&timers, &when);
3906 free(timers_expire(&timers, when));
3907 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3908 timer = malloc(sizeof(*timer));
3909 timer_init(timer);
3910 timer_addmono(&timers, timer, when);
3911 timer_earliest(&timers, &when);
3912 free(timers_expire(&timers, when));
3913 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3914 timer = malloc(sizeof(*timer));
3915 timer_init(timer);
3916 timer_addmono(&timers, timer, when);
3917 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
3918 timer = malloc(sizeof(*timer));
3919 timer_init(timer);
3920 timer_addmono(&timers, timer, when);
3921 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3922 timer = malloc(sizeof(*timer));
3923 timer_init(timer);
3924 timer_addmono(&timers, timer, when);
3925 timer_earliest(&timers, &when);
3926 free(timers_expire(&timers, when));
3927 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3928 timer = malloc(sizeof(*timer));
3929 timer_init(timer);
3930 timer_addmono(&timers, timer, when);
3931 timer_earliest(&timers, &when);
3932 free(timers_expire(&timers, when));
3933 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3934 timer = malloc(sizeof(*timer));
3935 timer_init(timer);
3936 timer_addmono(&timers, timer, when);
3937 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3938 timer = malloc(sizeof(*timer));
3939 timer_init(timer);
3940 timer_addmono(&timers, timer, when);
3941 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3942 timer = malloc(sizeof(*timer));
3943 timer_init(timer);
3944 timer_addmono(&timers, timer, when);
3945 timer_earliest(&timers, &when);
3946 free(timers_expire(&timers, when));
3947 timer_earliest(&timers, &when);
3948 free(timers_expire(&timers, when));
3949 timer_earliest(&timers, &when);
3950 free(timers_expire(&timers, when));
3951 timer_earliest(&timers, &when);
3952 free(timers_expire(&timers, when));
3953 timer_earliest(&timers, &when);
3954 free(timers_expire(&timers, when));
3955 timer_earliest(&timers, &when);
3956 free(timers_expire(&timers, when));
3957 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3958 timer = malloc(sizeof(*timer));
3959 timer_init(timer);
3960 timer_addmono(&timers, timer, when);
3961 timer_earliest(&timers, &when);
3962 free(timers_expire(&timers, when));
3963 timer_earliest(&timers, &when);
3964 free(timers_expire(&timers, when));
3965 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3966 timer = malloc(sizeof(*timer));
3967 timer_init(timer);
3968 timer_addmono(&timers, timer, when);
3969 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3970 timer = malloc(sizeof(*timer));
3971 timer_init(timer);
3972 timer_addmono(&timers, timer, when);
3973 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
3974 timer = malloc(sizeof(*timer));
3975 timer_init(timer);
3976 timer_addmono(&timers, timer, when);
3977 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
3978 timer = malloc(sizeof(*timer));
3979 timer_init(timer);
3980 timer_addmono(&timers, timer, when);
3981 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
3982 timer = malloc(sizeof(*timer));
3983 timer_init(timer);
3984 timer_addmono(&timers, timer, when);
3985 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
3986 timer = malloc(sizeof(*timer));
3987 timer_init(timer);
3988 timer_addmono(&timers, timer, when);
3989 timer_earliest(&timers, &when);
3990 free(timers_expire(&timers, when));
3991 timer_earliest(&timers, &when);
3992 free(timers_expire(&timers, when));
3993 timer_earliest(&timers, &when);
3994 free(timers_expire(&timers, when));
3995 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3996 timer = malloc(sizeof(*timer));
3997 timer_init(timer);
3998 timer_addmono(&timers, timer, when);
3999 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
4000 timer = malloc(sizeof(*timer));
4001 timer_init(timer);
4002 timer_addmono(&timers, timer, when);
4003 when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
4004 timer = malloc(sizeof(*timer));
4005 timer_init(timer);
4006 timer_addmono(&timers, timer, when);
4007 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4008 timer = malloc(sizeof(*timer));
4009 timer_init(timer);
4010 timer_addmono(&timers, timer, when);
4011 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4012 timer = malloc(sizeof(*timer));
4013 timer_init(timer);
4014 timer_addmono(&timers, timer, when);
4015 timer_earliest(&timers, &when);
4016 free(timers_expire(&timers, when));
4017 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
4018 timer = malloc(sizeof(*timer));
4019 timer_init(timer);
4020 timer_addmono(&timers, timer, when);
4021 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4022 timer = malloc(sizeof(*timer));
4023 timer_init(timer);
4024 timer_addmono(&timers, timer, when);
4025 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4026 timer = malloc(sizeof(*timer));
4027 timer_init(timer);
4028 timer_addmono(&timers, timer, when);
4029 timer_earliest(&timers, &when);
4030 free(timers_expire(&timers, when));
4031 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4032 timer = malloc(sizeof(*timer));
4033 timer_init(timer);
4034 timer_addmono(&timers, timer, when);
4035 timer_earliest(&timers, &when);
4036 free(timers_expire(&timers, when));
4037 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
4038 timer = malloc(sizeof(*timer));
4039 timer_init(timer);
4040 timer_addmono(&timers, timer, when);
4041 timer_earliest(&timers, &when);
4042 free(timers_expire(&timers, when));
4043 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4044 timer = malloc(sizeof(*timer));
4045 timer_init(timer);
4046 timer_addmono(&timers, timer, when);
4047 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4048 timer = malloc(sizeof(*timer));
4049 timer_init(timer);
4050 timer_addmono(&timers, timer, when);
4051 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
4052 timer = malloc(sizeof(*timer));
4053 timer_init(timer);
4054 timer_addmono(&timers, timer, when);
4055 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4056 timer = malloc(sizeof(*timer));
4057 timer_init(timer);
4058 timer_addmono(&timers, timer, when);
4059 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
4060 timer = malloc(sizeof(*timer));
4061 timer_init(timer);
4062 timer_addmono(&timers, timer, when);
4063 timer_earliest(&timers, &when);
4064 free(timers_expire(&timers, when));
4065 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4066 timer = malloc(sizeof(*timer));
4067 timer_init(timer);
4068 timer_addmono(&timers, timer, when);
4069 when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
4070 timer = malloc(sizeof(*timer));
4071 timer_init(timer);
4072 timer_addmono(&timers, timer, when);
4073 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4074 timer = malloc(sizeof(*timer));
4075 timer_init(timer);
4076 timer_addmono(&timers, timer, when);
4077 timer_earliest(&timers, &when);
4078 free(timers_expire(&timers, when));
4079 timer_earliest(&timers, &when);
4080 free(timers_expire(&timers, when));
4081 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
4082 timer = malloc(sizeof(*timer));
4083 timer_init(timer);
4084 timer_addmono(&timers, timer, when);
4085 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4086 timer = malloc(sizeof(*timer));
4087 timer_init(timer);
4088 timer_addmono(&timers, timer, when);
4089 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
4090 timer = malloc(sizeof(*timer));
4091 timer_init(timer);
4092 timer_addmono(&timers, timer, when);
4093 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4094 timer = malloc(sizeof(*timer));
4095 timer_init(timer);
4096 timer_addmono(&timers, timer, when);
4097 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
4098 timer = malloc(sizeof(*timer));
4099 timer_init(timer);
4100 timer_addmono(&timers, timer, when);
4101 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
4102 timer = malloc(sizeof(*timer));
4103 timer_init(timer);
4104 timer_addmono(&timers, timer, when);
4105 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
4106 timer = malloc(sizeof(*timer));
4107 timer_init(timer);
4108 timer_addmono(&timers, timer, when);
4109 timer_earliest(&timers, &when);
4110 free(timers_expire(&timers, when));
4111 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
4112 timer = malloc(sizeof(*timer));
4113 timer_init(timer);
4114 timer_addmono(&timers, timer, when);
4115 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
4116 timer = malloc(sizeof(*timer));
4117 timer_init(timer);
4118 timer_addmono(&timers, timer, when);
4119 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
4120 timer = malloc(sizeof(*timer));
4121 timer_init(timer);
4122 timer_addmono(&timers, timer, when);
4123 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4124 timer = malloc(sizeof(*timer));
4125 timer_init(timer);
4126 timer_addmono(&timers, timer, when);
4127 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
4128 timer = malloc(sizeof(*timer));
4129 timer_init(timer);
4130 timer_addmono(&timers, timer, when);
4131 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4132 timer = malloc(sizeof(*timer));
4133 timer_init(timer);
4134 timer_addmono(&timers, timer, when);
4135 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
4136 timer = malloc(sizeof(*timer));
4137 timer_init(timer);
4138 timer_addmono(&timers, timer, when);
4139 timer_earliest(&timers, &when);
4140 free(timers_expire(&timers, when));
4141 timer_earliest(&timers, &when);
4142 free(timers_expire(&timers, when));
4143 timer_earliest(&timers, &when);
4144 free(timers_expire(&timers, when));
4145 timer_earliest(&timers, &when);
4146 free(timers_expire(&timers, when));
4147 timer_earliest(&timers, &when);
4148 free(timers_expire(&timers, when));
4149 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
4150 timer = malloc(sizeof(*timer));
4151 timer_init(timer);
4152 timer_addmono(&timers, timer, when);
4153 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
4154 timer = malloc(sizeof(*timer));
4155 timer_init(timer);
4156 timer_addmono(&timers, timer, when);
4157 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4158 timer = malloc(sizeof(*timer));
4159 timer_init(timer);
4160 timer_addmono(&timers, timer, when);
4161 timer_earliest(&timers, &when);
4162 free(timers_expire(&timers, when));
4163 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
4164 timer = malloc(sizeof(*timer));
4165 timer_init(timer);
4166 timer_addmono(&timers, timer, when);
4167 timer_earliest(&timers, &when);
4168 free(timers_expire(&timers, when));
4169 timer_earliest(&timers, &when);
4170 free(timers_expire(&timers, when));
4171 timer_earliest(&timers, &when);
4172 free(timers_expire(&timers, when));
4173 timer_earliest(&timers, &when);
4174 free(timers_expire(&timers, when));
4175 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
4176 timer = malloc(sizeof(*timer));
4177 timer_init(timer);
4178 timer_addmono(&timers, timer, when);
4179 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
4180 timer = malloc(sizeof(*timer));
4181 timer_init(timer);
4182 timer_addmono(&timers, timer, when);
4183 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
4184 timer = malloc(sizeof(*timer));
4185 timer_init(timer);
4186 timer_addmono(&timers, timer, when);
4187 timer_earliest(&timers, &when);
4188 free(timers_expire(&timers, when));
4189 timer_earliest(&timers, &when);
4190 free(timers_expire(&timers, when));
4191 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
4192 timer = malloc(sizeof(*timer));
4193 timer_init(timer);
4194 timer_addmono(&timers, timer, when);
4195 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
4196 timer = malloc(sizeof(*timer));
4197 timer_init(timer);
4198 timer_addmono(&timers, timer, when);
4199 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4200 timer = malloc(sizeof(*timer));
4201 timer_init(timer);
4202 timer_addmono(&timers, timer, when);
4203 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4204 timer = malloc(sizeof(*timer));
4205 timer_init(timer);
4206 timer_addmono(&timers, timer, when);
4207 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
4208 timer = malloc(sizeof(*timer));
4209 timer_init(timer);
4210 timer_addmono(&timers, timer, when);
4211 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
4212 timer = malloc(sizeof(*timer));
4213 timer_init(timer);
4214 timer_addmono(&timers, timer, when);
4215 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
4216 timer = malloc(sizeof(*timer));
4217 timer_init(timer);
4218 timer_addmono(&timers, timer, when);
4219 timer_earliest(&timers, &when);
4220 free(timers_expire(&timers, when));
4221 timer_earliest(&timers, &when);
4222 free(timers_expire(&timers, when));
4223 timer_earliest(&timers, &when);
4224 free(timers_expire(&timers, when));
4225 timer_earliest(&timers, &when);
4226 free(timers_expire(&timers, when));
4227 timer_earliest(&timers, &when);
4228 free(timers_expire(&timers, when));
4229 timer_earliest(&timers, &when);
4230 free(timers_expire(&timers, when));
4231 when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
4232 timer = malloc(sizeof(*timer));
4233 timer_init(timer);
4234 timer_addmono(&timers, timer, when);
4235 timer_earliest(&timers, &when);
4236 free(timers_expire(&timers, when));
4237 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4238 timer = malloc(sizeof(*timer));
4239 timer_init(timer);
4240 timer_addmono(&timers, timer, when);
4241 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
4242 timer = malloc(sizeof(*timer));
4243 timer_init(timer);
4244 timer_addmono(&timers, timer, when);
4245 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4246 timer = malloc(sizeof(*timer));
4247 timer_init(timer);
4248 timer_addmono(&timers, timer, when);
4249 ok1(timers_check(&timers, NULL));
4250 timer_earliest(&timers, &when);
4251 free(timers_expire(&timers, when));
4252 timer_earliest(&timers, &when);
4253 free(timers_expire(&timers, when));
4254 timer_earliest(&timers, &when);
4255 free(timers_expire(&timers, when));
4256 timer_earliest(&timers, &when);
4257 free(timers_expire(&timers, when));
4258 timer_earliest(&timers, &when);
4259 free(timers_expire(&timers, when));
4260 timer_earliest(&timers, &when);
4261 free(timers_expire(&timers, when));
4262 timer_earliest(&timers, &when);
4263 free(timers_expire(&timers, when));
4264 timer_earliest(&timers, &when);
4265 free(timers_expire(&timers, when));
4266 timer_earliest(&timers, &when);
4267 free(timers_expire(&timers, when));
4268 timer_earliest(&timers, &when);
4269 free(timers_expire(&timers, when));
4270 timer_earliest(&timers, &when);
4271 free(timers_expire(&timers, when));
4272 timer_earliest(&timers, &when);
4273 free(timers_expire(&timers, when));
4274 timer_earliest(&timers, &when);
4275 free(timers_expire(&timers, when));
4276 timer_earliest(&timers, &when);
4277 free(timers_expire(&timers, when));
4278 timer_earliest(&timers, &when);
4279 free(timers_expire(&timers, when));
4280 timer_earliest(&timers, &when);
4281 free(timers_expire(&timers, when));
4282 timer_earliest(&timers, &when);
4283 free(timers_expire(&timers, when));
4284 timer_earliest(&timers, &when);
4285 free(timers_expire(&timers, when));
4286 timer_earliest(&timers, &when);
4287 free(timers_expire(&timers, when));
4288 timer_earliest(&timers, &when);
4289 free(timers_expire(&timers, when));
4290 timer_earliest(&timers, &when);
4291 free(timers_expire(&timers, when));
4292 timer_earliest(&timers, &when);
4293 free(timers_expire(&timers, when));
4294 timer_earliest(&timers, &when);
4295 free(timers_expire(&timers, when));
4296 timer_earliest(&timers, &when);
4297 free(timers_expire(&timers, when));
4298 timer_earliest(&timers, &when);
4299 free(timers_expire(&timers, when));
4300 timer_earliest(&timers, &when);
4301 free(timers_expire(&timers, when));
4302 timer_earliest(&timers, &when);
4303 free(timers_expire(&timers, when));
4304 timer_earliest(&timers, &when);
4305 free(timers_expire(&timers, when));
4306 timer_earliest(&timers, &when);
4307 free(timers_expire(&timers, when));
4308 timer_earliest(&timers, &when);
4309 free(timers_expire(&timers, when));
4310 timer_earliest(&timers, &when);
4311 free(timers_expire(&timers, when));
4312 timer_earliest(&timers, &when);
4313 free(timers_expire(&timers, when));
4314 timer_earliest(&timers, &when);
4315 free(timers_expire(&timers, when));
4316 timer_earliest(&timers, &when);
4317 free(timers_expire(&timers, when));
4318 timer_earliest(&timers, &when);
4319 free(timers_expire(&timers, when));
4320 timer_earliest(&timers, &when);
4321 free(timers_expire(&timers, when));
4322 timer_earliest(&timers, &when);
4323 free(timers_expire(&timers, when));
4324
4325 while (timer_earliest(&timers, &when)) {
4326 free(timers_expire(&timers, when));
4327 }
4328 ok1(timers_check(&timers, NULL));
4329 timers_cleanup(&timers);
4330
4331 return exit_status();
4332 }
4333