timer: change to use time_mono (api break!)
[ccan] / ccan / timer / test / run-original-corrupt.c
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. */
8 int main(int argc, char *argv[])
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;