1 #define CCAN_TIMER_DEBUG 1
2 #include <ccan/timer/timer.h>
3 /* Include the C files directly. */
4 #include <ccan/timer/timer.c>
5 #include <ccan/tap/tap.h>
6
7 /* This is the original pre-cut-down dump. */
main(void)8 int main(void)
9 {
10 struct timemono when;
11 struct timers timers;
12 struct timer *timer;
13
14 plan_tests(1);
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1627 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1628 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1629 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1630 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1631 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1632 timer = malloc(sizeof(*timer));
1633 timer_init(timer);
1634 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1643 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1644 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1645 when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
1646 timer = malloc(sizeof(*timer));
1647 timer_init(timer);
1648 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1653 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1654 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1655 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
1656 timer = malloc(sizeof(*timer));
1657 timer_init(timer);
1658 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1671 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1672 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1673 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1674 timer = malloc(sizeof(*timer));
1675 timer_init(timer);
1676 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1685 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1686 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1687 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1688 timer = malloc(sizeof(*timer));
1689 timer_init(timer);
1690 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1715 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1716 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1717 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1718 timer = malloc(sizeof(*timer));
1719 timer_init(timer);
1720 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1729 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1730 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1731 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1732 timer = malloc(sizeof(*timer));
1733 timer_init(timer);
1734 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1745 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1746 timer = malloc(sizeof(*timer));
1747 timer_init(timer);
1748 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1773 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1774 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1775 when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1776 timer = malloc(sizeof(*timer));
1777 timer_init(timer);
1778 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1787 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1788 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1789 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1790 timer = malloc(sizeof(*timer));
1791 timer_init(timer);
1792 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1801 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1802 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1803 when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
1804 timer = malloc(sizeof(*timer));
1805 timer_init(timer);
1806 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1823 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1824 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1825 when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1826 timer = malloc(sizeof(*timer));
1827 timer_init(timer);
1828 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1837 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1838 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1839 when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
1840 timer = malloc(sizeof(*timer));
1841 timer_init(timer);
1842 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1849 when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1850 timer = malloc(sizeof(*timer));
1851 timer_init(timer);
1852 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
1853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1855 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1856 timer = malloc(sizeof(*timer));
1857 timer_init(timer);
1858 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1867 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1868 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1869 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1870 timer = malloc(sizeof(*timer));
1871 timer_init(timer);
1872 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1889 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1890 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1891 when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1892 timer = malloc(sizeof(*timer));
1893 timer_init(timer);
1894 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1919 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1920 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1921 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1922 timer = malloc(sizeof(*timer));
1923 timer_init(timer);
1924 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1951 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
1952 timer = malloc(sizeof(*timer));
1953 timer_init(timer);
1954 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1959 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1960 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1961 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1962 timer = malloc(sizeof(*timer));
1963 timer_init(timer);
1964 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1981 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1982 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1983 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1984 timer = malloc(sizeof(*timer));
1985 timer_init(timer);
1986 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
1995 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1996 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1997 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
1998 timer = malloc(sizeof(*timer));
1999 timer_init(timer);
2000 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2005 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2006 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2007 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
2008 timer = malloc(sizeof(*timer));
2009 timer_init(timer);
2010 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2015 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2016 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2017 when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2018 timer = malloc(sizeof(*timer));
2019 timer_init(timer);
2020 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2041 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2042 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2043 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2044 timer = malloc(sizeof(*timer));
2045 timer_init(timer);
2046 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2055 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2056 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2057 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2058 timer = malloc(sizeof(*timer));
2059 timer_init(timer);
2060 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2089 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2090 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2091 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2092 timer = malloc(sizeof(*timer));
2093 timer_init(timer);
2094 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2115 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2116 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2117 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2118 timer = malloc(sizeof(*timer));
2119 timer_init(timer);
2120 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2149 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2150 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2151 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2152 timer = malloc(sizeof(*timer));
2153 timer_init(timer);
2154 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2171 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2172 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2173 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2174 timer = malloc(sizeof(*timer));
2175 timer_init(timer);
2176 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2181 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2182 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2183 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2184 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2185 when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2186 timer = malloc(sizeof(*timer));
2187 timer_init(timer);
2188 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2205 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2206 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2207 when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
2208 timer = malloc(sizeof(*timer));
2209 timer_init(timer);
2210 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2219 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2220 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2221 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
2222 timer = malloc(sizeof(*timer));
2223 timer_init(timer);
2224 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2229 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2230 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2231 when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
2232 timer = malloc(sizeof(*timer));
2233 timer_init(timer);
2234 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2247 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2248 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2249 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2250 timer = malloc(sizeof(*timer));
2251 timer_init(timer);
2252 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2253 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2254 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2255 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2256 timer = malloc(sizeof(*timer));
2257 timer_init(timer);
2258 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2275 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2276 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2277 when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2278 timer = malloc(sizeof(*timer));
2279 timer_init(timer);
2280 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2299 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2300 timer = malloc(sizeof(*timer));
2301 timer_init(timer);
2302 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2307 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2308 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2309 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2310 timer = malloc(sizeof(*timer));
2311 timer_init(timer);
2312 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2329 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2330 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2331 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
2332 timer = malloc(sizeof(*timer));
2333 timer_init(timer);
2334 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2347 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2348 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2349 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2350 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2351 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2352 timer = malloc(sizeof(*timer));
2353 timer_init(timer);
2354 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2363 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2364 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2365 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2366 timer = malloc(sizeof(*timer));
2367 timer_init(timer);
2368 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2389 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2390 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2391 when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000;
2392 timer = malloc(sizeof(*timer));
2393 timer_init(timer);
2394 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2403 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2404 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2405 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2406 timer = malloc(sizeof(*timer));
2407 timer_init(timer);
2408 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2409 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2410 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2411 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2412 timer = malloc(sizeof(*timer));
2413 timer_init(timer);
2414 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2423 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2424 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2425 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2426 timer = malloc(sizeof(*timer));
2427 timer_init(timer);
2428 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2437 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2438 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2439 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
2440 timer = malloc(sizeof(*timer));
2441 timer_init(timer);
2442 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2447 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2448 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2449 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2450 timer = malloc(sizeof(*timer));
2451 timer_init(timer);
2452 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2461 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2462 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2463 when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
2464 timer = malloc(sizeof(*timer));
2465 timer_init(timer);
2466 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2471 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2472 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2473 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
2474 timer = malloc(sizeof(*timer));
2475 timer_init(timer);
2476 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2477 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2478 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2479 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
2480 timer = malloc(sizeof(*timer));
2481 timer_init(timer);
2482 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2491 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2492 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2493 when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2494 timer = malloc(sizeof(*timer));
2495 timer_init(timer);
2496 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2511 when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
2512 timer = malloc(sizeof(*timer));
2513 timer_init(timer);
2514 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2519 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2520 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2521 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
2522 timer = malloc(sizeof(*timer));
2523 timer_init(timer);
2524 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2549 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2550 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2551 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2552 timer = malloc(sizeof(*timer));
2553 timer_init(timer);
2554 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2555 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2556 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2557 when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000;
2558 timer = malloc(sizeof(*timer));
2559 timer_init(timer);
2560 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2573 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2574 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2575 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2576 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2577 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2578 timer = malloc(sizeof(*timer));
2579 timer_init(timer);
2580 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2591 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2592 timer = malloc(sizeof(*timer));
2593 timer_init(timer);
2594 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2611 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2612 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2613 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2614 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2615 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2616 timer = malloc(sizeof(*timer));
2617 timer_init(timer);
2618 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2631 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2632 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2633 when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
2634 timer = malloc(sizeof(*timer));
2635 timer_init(timer);
2636 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2653 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2654 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2655 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2656 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2657 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2658 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2659 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
2660 timer = malloc(sizeof(*timer));
2661 timer_init(timer);
2662 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2667 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2668 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2669 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2670 timer = malloc(sizeof(*timer));
2671 timer_init(timer);
2672 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2681 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2682 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2683 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
2684 timer = malloc(sizeof(*timer));
2685 timer_init(timer);
2686 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2695 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2696 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2697 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2698 timer = malloc(sizeof(*timer));
2699 timer_init(timer);
2700 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2713 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2714 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2715 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2716 timer = malloc(sizeof(*timer));
2717 timer_init(timer);
2718 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2727 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2728 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2729 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2730 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2731 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2732 timer = malloc(sizeof(*timer));
2733 timer_init(timer);
2734 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2745 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2746 timer = malloc(sizeof(*timer));
2747 timer_init(timer);
2748 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2753 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2754 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2755 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2756 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2757 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2758 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2759 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2760 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2761 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2762 timer = malloc(sizeof(*timer));
2763 timer_init(timer);
2764 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2789 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2790 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2791 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2792 timer = malloc(sizeof(*timer));
2793 timer_init(timer);
2794 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2811 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2812 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2813 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2814 timer = malloc(sizeof(*timer));
2815 timer_init(timer);
2816 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2817 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2818 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2819 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2820 timer = malloc(sizeof(*timer));
2821 timer_init(timer);
2822 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2849 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2850 timer = malloc(sizeof(*timer));
2851 timer_init(timer);
2852 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2873 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2874 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2875 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2876 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2877 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2878 timer = malloc(sizeof(*timer));
2879 timer_init(timer);
2880 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2881 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2882 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2883 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
2884 timer = malloc(sizeof(*timer));
2885 timer_init(timer);
2886 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2887 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2888 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2889 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
2890 timer = malloc(sizeof(*timer));
2891 timer_init(timer);
2892 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2909 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2910 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2911 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2912 timer = malloc(sizeof(*timer));
2913 timer_init(timer);
2914 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
2915 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2916 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2917 when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
2918 timer = malloc(sizeof(*timer));
2919 timer_init(timer);
2920 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2933 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2934 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2935 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2936 timer = malloc(sizeof(*timer));
2937 timer_init(timer);
2938 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2947 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2948 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2951 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2952 timer = malloc(sizeof(*timer));
2953 timer_init(timer);
2954 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2971 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2972 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2973 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
2974 timer = malloc(sizeof(*timer));
2975 timer_init(timer);
2976 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
2997 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2998 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2999 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3000 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3001 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3002 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3003 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3004 timer = malloc(sizeof(*timer));
3005 timer_init(timer);
3006 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3035 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3036 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3037 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3038 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3039 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3040 timer = malloc(sizeof(*timer));
3041 timer_init(timer);
3042 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3055 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3056 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3057 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3058 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3059 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3060 timer = malloc(sizeof(*timer));
3061 timer_init(timer);
3062 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3079 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3080 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3081 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3082 timer = malloc(sizeof(*timer));
3083 timer_init(timer);
3084 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3089 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3090 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3091 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3092 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3093 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3094 timer = malloc(sizeof(*timer));
3095 timer_init(timer);
3096 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3101 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3102 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3103 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3104 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3105 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
3106 timer = malloc(sizeof(*timer));
3107 timer_init(timer);
3108 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3125 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3126 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3127 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3128 timer = malloc(sizeof(*timer));
3129 timer_init(timer);
3130 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3155 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3156 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3157 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3158 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3159 when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3160 timer = malloc(sizeof(*timer));
3161 timer_init(timer);
3162 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3171 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3172 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3173 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3174 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3175 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3176 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3177 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3178 timer = malloc(sizeof(*timer));
3179 timer_init(timer);
3180 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3189 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3190 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3191 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3192 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3193 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3194 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3195 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
3196 timer = malloc(sizeof(*timer));
3197 timer_init(timer);
3198 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3223 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3224 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3225 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3226 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3227 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3228 timer = malloc(sizeof(*timer));
3229 timer_init(timer);
3230 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3243 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3244 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3245 when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
3246 timer = malloc(sizeof(*timer));
3247 timer_init(timer);
3248 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3249 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3250 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3251 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
3252 timer = malloc(sizeof(*timer));
3253 timer_init(timer);
3254 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3255 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3256 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3257 when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
3258 timer = malloc(sizeof(*timer));
3259 timer_init(timer);
3260 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3273 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3274 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3275 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
3276 timer = malloc(sizeof(*timer));
3277 timer_init(timer);
3278 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3287 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3288 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3289 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3290 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3291 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3292 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3293 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3294 timer = malloc(sizeof(*timer));
3295 timer_init(timer);
3296 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3299 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3300 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3301 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
3302 timer = malloc(sizeof(*timer));
3303 timer_init(timer);
3304 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3317 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3318 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3319 when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
3320 timer = malloc(sizeof(*timer));
3321 timer_init(timer);
3322 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
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); timers_check(&timers, "add");
3347 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3348 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3349 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3350 timer = malloc(sizeof(*timer));
3351 timer_init(timer);
3352 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3353 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3354 timer = malloc(sizeof(*timer));
3355 timer_init(timer);
3356 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3357 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3358 timer = malloc(sizeof(*timer));
3359 timer_init(timer);
3360 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3361 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3362 timer = malloc(sizeof(*timer));
3363 timer_init(timer);
3364 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3365 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3366 timer = malloc(sizeof(*timer));
3367 timer_init(timer);
3368 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3369 when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
3370 timer = malloc(sizeof(*timer));
3371 timer_init(timer);
3372 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3373 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
3374 timer = malloc(sizeof(*timer));
3375 timer_init(timer);
3376 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3377 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3378 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3379 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3380 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3381 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3382 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3383 when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
3384 timer = malloc(sizeof(*timer));
3385 timer_init(timer);
3386 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3387 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3388 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3389 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3390 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3391 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3392 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3393 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3394 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3395 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3396 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3397 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3398 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3399 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3400 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3401 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
3402 timer = malloc(sizeof(*timer));
3403 timer_init(timer);
3404 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3405 when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
3406 timer = malloc(sizeof(*timer));
3407 timer_init(timer);
3408 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3409 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3410 timer = malloc(sizeof(*timer));
3411 timer_init(timer);
3412 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3413 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3414 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3415 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3416 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3417 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3418 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3419 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3420 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3421 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3422 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3423 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3424 timer = malloc(sizeof(*timer));
3425 timer_init(timer);
3426 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3427 when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000;
3428 timer = malloc(sizeof(*timer));
3429 timer_init(timer);
3430 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3431 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3432 timer = malloc(sizeof(*timer));
3433 timer_init(timer);
3434 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3435 when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3436 timer = malloc(sizeof(*timer));
3437 timer_init(timer);
3438 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3439 when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3440 timer = malloc(sizeof(*timer));
3441 timer_init(timer);
3442 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3443 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3444 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3445 when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3446 timer = malloc(sizeof(*timer));
3447 timer_init(timer);
3448 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3449 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
3450 timer = malloc(sizeof(*timer));
3451 timer_init(timer);
3452 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3453 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3454 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3455 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
3456 timer = malloc(sizeof(*timer));
3457 timer_init(timer);
3458 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3459 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
3460 timer = malloc(sizeof(*timer));
3461 timer_init(timer);
3462 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3463 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
3464 timer = malloc(sizeof(*timer));
3465 timer_init(timer);
3466 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3467 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3468 timer = malloc(sizeof(*timer));
3469 timer_init(timer);
3470 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3471 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3472 timer = malloc(sizeof(*timer));
3473 timer_init(timer);
3474 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3475 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3476 timer = malloc(sizeof(*timer));
3477 timer_init(timer);
3478 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3479 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3480 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3481 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3482 timer = malloc(sizeof(*timer));
3483 timer_init(timer);
3484 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3485 when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
3486 timer = malloc(sizeof(*timer));
3487 timer_init(timer);
3488 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3489 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
3490 timer = malloc(sizeof(*timer));
3491 timer_init(timer);
3492 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3493 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3494 timer = malloc(sizeof(*timer));
3495 timer_init(timer);
3496 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3497 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
3498 timer = malloc(sizeof(*timer));
3499 timer_init(timer);
3500 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3501 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3502 timer = malloc(sizeof(*timer));
3503 timer_init(timer);
3504 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3505 when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
3506 timer = malloc(sizeof(*timer));
3507 timer_init(timer);
3508 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3511 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
3512 timer = malloc(sizeof(*timer));
3513 timer_init(timer);
3514 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3515 when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
3516 timer = malloc(sizeof(*timer));
3517 timer_init(timer);
3518 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3519 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3520 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3521 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3522 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3523 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
3524 timer = malloc(sizeof(*timer));
3525 timer_init(timer);
3526 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3527 when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3528 timer = malloc(sizeof(*timer));
3529 timer_init(timer);
3530 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3531 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
3532 timer = malloc(sizeof(*timer));
3533 timer_init(timer);
3534 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3535 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3536 timer = malloc(sizeof(*timer));
3537 timer_init(timer);
3538 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3539 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
3540 timer = malloc(sizeof(*timer));
3541 timer_init(timer);
3542 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3543 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
3544 timer = malloc(sizeof(*timer));
3545 timer_init(timer);
3546 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3547 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3548 timer = malloc(sizeof(*timer));
3549 timer_init(timer);
3550 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3551 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3552 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3553 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3554 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3555 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3556 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3557 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
3558 timer = malloc(sizeof(*timer));
3559 timer_init(timer);
3560 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3561 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3562 timer = malloc(sizeof(*timer));
3563 timer_init(timer);
3564 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3565 when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
3566 timer = malloc(sizeof(*timer));
3567 timer_init(timer);
3568 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3569 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3570 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3571 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3572 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3573 when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3574 timer = malloc(sizeof(*timer));
3575 timer_init(timer);
3576 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3577 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3578 timer = malloc(sizeof(*timer));
3579 timer_init(timer);
3580 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3581 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3582 timer = malloc(sizeof(*timer));
3583 timer_init(timer);
3584 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3585 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3586 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3587 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3588 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3591 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3592 timer = malloc(sizeof(*timer));
3593 timer_init(timer);
3594 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3595 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
3596 timer = malloc(sizeof(*timer));
3597 timer_init(timer);
3598 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3599 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3600 timer = malloc(sizeof(*timer));
3601 timer_init(timer);
3602 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3603 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
3604 timer = malloc(sizeof(*timer));
3605 timer_init(timer);
3606 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3607 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3608 timer = malloc(sizeof(*timer));
3609 timer_init(timer);
3610 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3611 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3612 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3613 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3614 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3615 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3616 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3617 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3618 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3619 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3620 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3621 when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3622 timer = malloc(sizeof(*timer));
3623 timer_init(timer);
3624 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3625 when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
3626 timer = malloc(sizeof(*timer));
3627 timer_init(timer);
3628 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3629 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3630 timer = malloc(sizeof(*timer));
3631 timer_init(timer);
3632 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3633 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
3634 timer = malloc(sizeof(*timer));
3635 timer_init(timer);
3636 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3637 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
3638 timer = malloc(sizeof(*timer));
3639 timer_init(timer);
3640 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3641 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3642 timer = malloc(sizeof(*timer));
3643 timer_init(timer);
3644 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3645 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3646 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3647 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3648 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3649 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3650 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3651 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3652 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3653 when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3654 timer = malloc(sizeof(*timer));
3655 timer_init(timer);
3656 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3657 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3658 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3659 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3660 timer = malloc(sizeof(*timer));
3661 timer_init(timer);
3662 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3663 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3664 timer = malloc(sizeof(*timer));
3665 timer_init(timer);
3666 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3667 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3668 timer = malloc(sizeof(*timer));
3669 timer_init(timer);
3670 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3671 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3672 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3673 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3674 timer = malloc(sizeof(*timer));
3675 timer_init(timer);
3676 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3677 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3678 timer = malloc(sizeof(*timer));
3679 timer_init(timer);
3680 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3681 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
3682 timer = malloc(sizeof(*timer));
3683 timer_init(timer);
3684 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3685 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3686 timer = malloc(sizeof(*timer));
3687 timer_init(timer);
3688 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3689 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3690 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3691 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3692 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3693 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3694 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3695 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
3696 timer = malloc(sizeof(*timer));
3697 timer_init(timer);
3698 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3699 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
3700 timer = malloc(sizeof(*timer));
3701 timer_init(timer);
3702 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3703 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3704 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3705 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3706 timer = malloc(sizeof(*timer));
3707 timer_init(timer);
3708 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3709 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3710 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3711 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3712 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3713 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3714 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3715 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3716 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3717 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3718 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3719 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3720 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3721 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3722 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3723 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3724 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3725 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3726 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3727 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
3728 timer = malloc(sizeof(*timer));
3729 timer_init(timer);
3730 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3731 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3732 timer = malloc(sizeof(*timer));
3733 timer_init(timer);
3734 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3735 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3736 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3737 when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3738 timer = malloc(sizeof(*timer));
3739 timer_init(timer);
3740 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3741 when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
3742 timer = malloc(sizeof(*timer));
3743 timer_init(timer);
3744 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3745 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3746 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3747 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3748 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3749 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3750 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3751 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3752 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3753 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3754 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3755 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
3756 timer = malloc(sizeof(*timer));
3757 timer_init(timer);
3758 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3759 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
3760 timer = malloc(sizeof(*timer));
3761 timer_init(timer);
3762 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3763 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3764 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3765 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3766 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3767 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3768 timer = malloc(sizeof(*timer));
3769 timer_init(timer);
3770 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3771 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3772 timer = malloc(sizeof(*timer));
3773 timer_init(timer);
3774 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3775 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3776 timer = malloc(sizeof(*timer));
3777 timer_init(timer);
3778 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3779 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
3780 timer = malloc(sizeof(*timer));
3781 timer_init(timer);
3782 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3783 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3784 timer = malloc(sizeof(*timer));
3785 timer_init(timer);
3786 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3787 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3788 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3789 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3790 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3791 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3792 timer = malloc(sizeof(*timer));
3793 timer_init(timer);
3794 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3795 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3796 timer = malloc(sizeof(*timer));
3797 timer_init(timer);
3798 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3799 when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3800 timer = malloc(sizeof(*timer));
3801 timer_init(timer);
3802 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3803 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3804 timer = malloc(sizeof(*timer));
3805 timer_init(timer);
3806 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3807 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3808 timer = malloc(sizeof(*timer));
3809 timer_init(timer);
3810 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3811 when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3812 timer = malloc(sizeof(*timer));
3813 timer_init(timer);
3814 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3815 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3816 timer = malloc(sizeof(*timer));
3817 timer_init(timer);
3818 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3819 when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
3820 timer = malloc(sizeof(*timer));
3821 timer_init(timer);
3822 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3823 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3824 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3825 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3826 timer = malloc(sizeof(*timer));
3827 timer_init(timer);
3828 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3829 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
3830 timer = malloc(sizeof(*timer));
3831 timer_init(timer);
3832 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3833 when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3834 timer = malloc(sizeof(*timer));
3835 timer_init(timer);
3836 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3837 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
3838 timer = malloc(sizeof(*timer));
3839 timer_init(timer);
3840 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3841 when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000;
3842 timer = malloc(sizeof(*timer));
3843 timer_init(timer);
3844 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3845 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3846 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3849 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3850 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3851 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3852 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3855 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
3856 timer = malloc(sizeof(*timer));
3857 timer_init(timer);
3858 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3859 when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
3860 timer = malloc(sizeof(*timer));
3861 timer_init(timer);
3862 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3863 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
3864 timer = malloc(sizeof(*timer));
3865 timer_init(timer);
3866 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3867 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3868 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3869 when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
3870 timer = malloc(sizeof(*timer));
3871 timer_init(timer);
3872 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3873 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3874 timer = malloc(sizeof(*timer));
3875 timer_init(timer);
3876 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3877 when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000;
3878 timer = malloc(sizeof(*timer));
3879 timer_init(timer);
3880 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3881 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3882 timer = malloc(sizeof(*timer));
3883 timer_init(timer);
3884 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3885 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3886 timer = malloc(sizeof(*timer));
3887 timer_init(timer);
3888 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3889 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3890 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3891 when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
3892 timer = malloc(sizeof(*timer));
3893 timer_init(timer);
3894 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3895 when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3896 timer = malloc(sizeof(*timer));
3897 timer_init(timer);
3898 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3899 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3900 timer = malloc(sizeof(*timer));
3901 timer_init(timer);
3902 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3903 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3904 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3905 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3906 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3907 when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3908 timer = malloc(sizeof(*timer));
3909 timer_init(timer);
3910 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3911 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3912 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3913 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3914 timer = malloc(sizeof(*timer));
3915 timer_init(timer);
3916 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3917 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
3918 timer = malloc(sizeof(*timer));
3919 timer_init(timer);
3920 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3921 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3922 timer = malloc(sizeof(*timer));
3923 timer_init(timer);
3924 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3925 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3926 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3927 when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3928 timer = malloc(sizeof(*timer));
3929 timer_init(timer);
3930 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3931 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3932 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3933 when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3934 timer = malloc(sizeof(*timer));
3935 timer_init(timer);
3936 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3937 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3938 timer = malloc(sizeof(*timer));
3939 timer_init(timer);
3940 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3941 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3942 timer = malloc(sizeof(*timer));
3943 timer_init(timer);
3944 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3945 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3946 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3947 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3948 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3951 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3952 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3953 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3954 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3955 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3956 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3957 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
3958 timer = malloc(sizeof(*timer));
3959 timer_init(timer);
3960 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3961 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3962 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3963 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3964 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3965 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
3966 timer = malloc(sizeof(*timer));
3967 timer_init(timer);
3968 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3969 when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3970 timer = malloc(sizeof(*timer));
3971 timer_init(timer);
3972 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3973 when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
3974 timer = malloc(sizeof(*timer));
3975 timer_init(timer);
3976 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3977 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
3978 timer = malloc(sizeof(*timer));
3979 timer_init(timer);
3980 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3981 when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
3982 timer = malloc(sizeof(*timer));
3983 timer_init(timer);
3984 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3985 when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
3986 timer = malloc(sizeof(*timer));
3987 timer_init(timer);
3988 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3989 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3990 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3991 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3992 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3993 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3994 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3995 when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3996 timer = malloc(sizeof(*timer));
3997 timer_init(timer);
3998 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
3999 when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
4000 timer = malloc(sizeof(*timer));
4001 timer_init(timer);
4002 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4003 when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
4004 timer = malloc(sizeof(*timer));
4005 timer_init(timer);
4006 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4007 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4008 timer = malloc(sizeof(*timer));
4009 timer_init(timer);
4010 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4011 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4012 timer = malloc(sizeof(*timer));
4013 timer_init(timer);
4014 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4015 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4016 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4017 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
4018 timer = malloc(sizeof(*timer));
4019 timer_init(timer);
4020 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4021 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4022 timer = malloc(sizeof(*timer));
4023 timer_init(timer);
4024 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4025 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4026 timer = malloc(sizeof(*timer));
4027 timer_init(timer);
4028 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4029 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4030 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4031 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4032 timer = malloc(sizeof(*timer));
4033 timer_init(timer);
4034 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4035 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4036 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4037 when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
4038 timer = malloc(sizeof(*timer));
4039 timer_init(timer);
4040 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4041 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4042 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4043 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4044 timer = malloc(sizeof(*timer));
4045 timer_init(timer);
4046 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4047 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4048 timer = malloc(sizeof(*timer));
4049 timer_init(timer);
4050 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4051 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
4052 timer = malloc(sizeof(*timer));
4053 timer_init(timer);
4054 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4055 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4056 timer = malloc(sizeof(*timer));
4057 timer_init(timer);
4058 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4059 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
4060 timer = malloc(sizeof(*timer));
4061 timer_init(timer);
4062 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4063 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4064 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4065 when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000;
4066 timer = malloc(sizeof(*timer));
4067 timer_init(timer);
4068 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4069 when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
4070 timer = malloc(sizeof(*timer));
4071 timer_init(timer);
4072 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4073 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4074 timer = malloc(sizeof(*timer));
4075 timer_init(timer);
4076 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4077 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4078 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4079 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4080 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4081 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
4082 timer = malloc(sizeof(*timer));
4083 timer_init(timer);
4084 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4085 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4086 timer = malloc(sizeof(*timer));
4087 timer_init(timer);
4088 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4089 when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
4090 timer = malloc(sizeof(*timer));
4091 timer_init(timer);
4092 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4093 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4094 timer = malloc(sizeof(*timer));
4095 timer_init(timer);
4096 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4097 when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
4098 timer = malloc(sizeof(*timer));
4099 timer_init(timer);
4100 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4101 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
4102 timer = malloc(sizeof(*timer));
4103 timer_init(timer);
4104 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4105 when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
4106 timer = malloc(sizeof(*timer));
4107 timer_init(timer);
4108 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4109 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4110 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4111 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
4112 timer = malloc(sizeof(*timer));
4113 timer_init(timer);
4114 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4115 when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
4116 timer = malloc(sizeof(*timer));
4117 timer_init(timer);
4118 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4119 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
4120 timer = malloc(sizeof(*timer));
4121 timer_init(timer);
4122 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4123 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4124 timer = malloc(sizeof(*timer));
4125 timer_init(timer);
4126 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4127 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
4128 timer = malloc(sizeof(*timer));
4129 timer_init(timer);
4130 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4131 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
4132 timer = malloc(sizeof(*timer));
4133 timer_init(timer);
4134 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4135 when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000;
4136 timer = malloc(sizeof(*timer));
4137 timer_init(timer);
4138 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4139 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4140 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4141 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4142 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4143 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4144 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4145 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4146 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4147 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4148 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4149 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
4150 timer = malloc(sizeof(*timer));
4151 timer_init(timer);
4152 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4153 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
4154 timer = malloc(sizeof(*timer));
4155 timer_init(timer);
4156 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4157 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4158 timer = malloc(sizeof(*timer));
4159 timer_init(timer);
4160 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4161 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4162 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4163 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
4164 timer = malloc(sizeof(*timer));
4165 timer_init(timer);
4166 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4167 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4168 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4169 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4170 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4171 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4172 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4173 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4174 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4175 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
4176 timer = malloc(sizeof(*timer));
4177 timer_init(timer);
4178 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4179 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
4180 timer = malloc(sizeof(*timer));
4181 timer_init(timer);
4182 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4183 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
4184 timer = malloc(sizeof(*timer));
4185 timer_init(timer);
4186 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4187 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4188 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4189 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4190 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4191 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
4192 timer = malloc(sizeof(*timer));
4193 timer_init(timer);
4194 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4195 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
4196 timer = malloc(sizeof(*timer));
4197 timer_init(timer);
4198 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4199 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4200 timer = malloc(sizeof(*timer));
4201 timer_init(timer);
4202 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4203 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4204 timer = malloc(sizeof(*timer));
4205 timer_init(timer);
4206 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4207 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
4208 timer = malloc(sizeof(*timer));
4209 timer_init(timer);
4210 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4211 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
4212 timer = malloc(sizeof(*timer));
4213 timer_init(timer);
4214 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4215 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
4216 timer = malloc(sizeof(*timer));
4217 timer_init(timer);
4218 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4219 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4220 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4221 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4222 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4223 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4224 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4225 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4226 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4227 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4228 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4229 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4230 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4231 when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
4232 timer = malloc(sizeof(*timer));
4233 timer_init(timer);
4234 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4235 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4236 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4237 when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
4238 timer = malloc(sizeof(*timer));
4239 timer_init(timer);
4240 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4241 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
4242 timer = malloc(sizeof(*timer));
4243 timer_init(timer);
4244 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4245 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4246 timer = malloc(sizeof(*timer));
4247 timer_init(timer);
4248 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4249 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4250 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4251 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4252 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4253 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4254 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4255 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
4256 timer = malloc(sizeof(*timer));
4257 timer_init(timer);
4258 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4259 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
4260 timer = malloc(sizeof(*timer));
4261 timer_init(timer);
4262 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4263 when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
4264 timer = malloc(sizeof(*timer));
4265 timer_init(timer);
4266 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4267 when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
4268 timer = malloc(sizeof(*timer));
4269 timer_init(timer);
4270 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4271 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4272 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4273 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4274 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4275 when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
4276 timer = malloc(sizeof(*timer));
4277 timer_init(timer);
4278 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4279 when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
4280 timer = malloc(sizeof(*timer));
4281 timer_init(timer);
4282 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4283 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
4284 timer = malloc(sizeof(*timer));
4285 timer_init(timer);
4286 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4287 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4288 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4289 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4290 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4291 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4292 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4293 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4294 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4295 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4296 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4299 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
4300 timer = malloc(sizeof(*timer));
4301 timer_init(timer);
4302 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4303 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4304 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4305 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4306 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4307 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4308 timer = malloc(sizeof(*timer));
4309 timer_init(timer);
4310 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4311 when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000;
4312 timer = malloc(sizeof(*timer));
4313 timer_init(timer);
4314 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4315 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4316 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4317 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4318 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4319 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4320 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4321 when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
4322 timer = malloc(sizeof(*timer));
4323 timer_init(timer);
4324 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4325 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
4326 timer = malloc(sizeof(*timer));
4327 timer_init(timer);
4328 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4329 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4330 timer = malloc(sizeof(*timer));
4331 timer_init(timer);
4332 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4333 when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
4334 timer = malloc(sizeof(*timer));
4335 timer_init(timer);
4336 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4337 when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
4338 timer = malloc(sizeof(*timer));
4339 timer_init(timer);
4340 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4341 when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
4342 timer = malloc(sizeof(*timer));
4343 timer_init(timer);
4344 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4345 when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
4346 timer = malloc(sizeof(*timer));
4347 timer_init(timer);
4348 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4349 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4350 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4351 when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000;
4352 timer = malloc(sizeof(*timer));
4353 timer_init(timer);
4354 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4355 when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
4356 timer = malloc(sizeof(*timer));
4357 timer_init(timer);
4358 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4359 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
4360 timer = malloc(sizeof(*timer));
4361 timer_init(timer);
4362 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4363 when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
4364 timer = malloc(sizeof(*timer));
4365 timer_init(timer);
4366 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4367 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4368 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4369 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4370 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4371 when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
4372 timer = malloc(sizeof(*timer));
4373 timer_init(timer);
4374 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4375 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4376 timer = malloc(sizeof(*timer));
4377 timer_init(timer);
4378 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4379 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
4380 timer = malloc(sizeof(*timer));
4381 timer_init(timer);
4382 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4383 when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
4384 timer = malloc(sizeof(*timer));
4385 timer_init(timer);
4386 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4387 when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
4388 timer = malloc(sizeof(*timer));
4389 timer_init(timer);
4390 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4391 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
4392 timer = malloc(sizeof(*timer));
4393 timer_init(timer);
4394 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4395 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4396 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4397 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
4398 timer = malloc(sizeof(*timer));
4399 timer_init(timer);
4400 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4401 when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
4402 timer = malloc(sizeof(*timer));
4403 timer_init(timer);
4404 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4405 when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
4406 timer = malloc(sizeof(*timer));
4407 timer_init(timer);
4408 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4409 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4410 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4411 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4412 timer = malloc(sizeof(*timer));
4413 timer_init(timer);
4414 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4415 when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000;
4416 timer = malloc(sizeof(*timer));
4417 timer_init(timer);
4418 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4419 when.ts.tv_sec = 0; when.ts.tv_nsec = 307000000;
4420 timer = malloc(sizeof(*timer));
4421 timer_init(timer);
4422 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4423 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4424 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4425 when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000;
4426 timer = malloc(sizeof(*timer));
4427 timer_init(timer);
4428 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4429 when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
4430 timer = malloc(sizeof(*timer));
4431 timer_init(timer);
4432 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4433 when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
4434 timer = malloc(sizeof(*timer));
4435 timer_init(timer);
4436 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4437 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4438 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4439 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4440 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4441 when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
4442 timer = malloc(sizeof(*timer));
4443 timer_init(timer);
4444 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4445 when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000;
4446 timer = malloc(sizeof(*timer));
4447 timer_init(timer);
4448 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4449 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4450 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4451 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4452 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4453 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
4454 timer = malloc(sizeof(*timer));
4455 timer_init(timer);
4456 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4457 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
4458 timer = malloc(sizeof(*timer));
4459 timer_init(timer);
4460 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4461 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4462 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4463 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4464 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4465 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4466 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4467 when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
4468 timer = malloc(sizeof(*timer));
4469 timer_init(timer);
4470 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4471 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4472 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4473 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4474 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4475 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4476 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4477 when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000;
4478 timer = malloc(sizeof(*timer));
4479 timer_init(timer);
4480 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4481 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4482 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4483 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
4484 timer = malloc(sizeof(*timer));
4485 timer_init(timer);
4486 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4487 when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
4488 timer = malloc(sizeof(*timer));
4489 timer_init(timer);
4490 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4491 when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
4492 timer = malloc(sizeof(*timer));
4493 timer_init(timer);
4494 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4495 when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
4496 timer = malloc(sizeof(*timer));
4497 timer_init(timer);
4498 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4499 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4500 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4501 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4502 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4503 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4504 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4505 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4506 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4507 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4508 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4511 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4512 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4513 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4514 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4515 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4516 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4517 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
4518 timer = malloc(sizeof(*timer));
4519 timer_init(timer);
4520 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4521 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
4522 timer = malloc(sizeof(*timer));
4523 timer_init(timer);
4524 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4525 when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
4526 timer = malloc(sizeof(*timer));
4527 timer_init(timer);
4528 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4529 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4530 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4531 when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000;
4532 timer = malloc(sizeof(*timer));
4533 timer_init(timer);
4534 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4535 when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
4536 timer = malloc(sizeof(*timer));
4537 timer_init(timer);
4538 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4539 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
4540 timer = malloc(sizeof(*timer));
4541 timer_init(timer);
4542 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4543 when.ts.tv_sec = 0; when.ts.tv_nsec = 270000000;
4544 timer = malloc(sizeof(*timer));
4545 timer_init(timer);
4546 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4547 when.ts.tv_sec = 0; when.ts.tv_nsec = 237000000;
4548 timer = malloc(sizeof(*timer));
4549 timer_init(timer);
4550 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4551 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4552 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4553 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4554 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4555 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4556 timer = malloc(sizeof(*timer));
4557 timer_init(timer);
4558 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4559 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4560 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4561 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4562 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4563 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
4564 timer = malloc(sizeof(*timer));
4565 timer_init(timer);
4566 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4567 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4568 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4569 when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000;
4570 timer = malloc(sizeof(*timer));
4571 timer_init(timer);
4572 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4573 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
4574 timer = malloc(sizeof(*timer));
4575 timer_init(timer);
4576 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4577 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4578 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4579 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4580 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4581 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
4582 timer = malloc(sizeof(*timer));
4583 timer_init(timer);
4584 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4585 when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
4586 timer = malloc(sizeof(*timer));
4587 timer_init(timer);
4588 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4591 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4592 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4593 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4594 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4595 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
4596 timer = malloc(sizeof(*timer));
4597 timer_init(timer);
4598 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4599 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
4600 timer = malloc(sizeof(*timer));
4601 timer_init(timer);
4602 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4603 when.ts.tv_sec = 0; when.ts.tv_nsec = 117000000;
4604 timer = malloc(sizeof(*timer));
4605 timer_init(timer);
4606 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4607 when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
4608 timer = malloc(sizeof(*timer));
4609 timer_init(timer);
4610 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4611 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4612 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4613 when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
4614 timer = malloc(sizeof(*timer));
4615 timer_init(timer);
4616 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4617 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
4618 timer = malloc(sizeof(*timer));
4619 timer_init(timer);
4620 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4621 when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
4622 timer = malloc(sizeof(*timer));
4623 timer_init(timer);
4624 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4625 when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000;
4626 timer = malloc(sizeof(*timer));
4627 timer_init(timer);
4628 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4629 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
4630 timer = malloc(sizeof(*timer));
4631 timer_init(timer);
4632 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4633 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4634 timer = malloc(sizeof(*timer));
4635 timer_init(timer);
4636 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4637 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4638 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4639 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4640 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4641 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4642 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4643 when.ts.tv_sec = 0; when.ts.tv_nsec = 312000000;
4644 timer = malloc(sizeof(*timer));
4645 timer_init(timer);
4646 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4647 when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
4648 timer = malloc(sizeof(*timer));
4649 timer_init(timer);
4650 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4651 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4652 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4653 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
4654 timer = malloc(sizeof(*timer));
4655 timer_init(timer);
4656 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4657 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
4658 timer = malloc(sizeof(*timer));
4659 timer_init(timer);
4660 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4661 when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
4662 timer = malloc(sizeof(*timer));
4663 timer_init(timer);
4664 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4665 when.ts.tv_sec = 0; when.ts.tv_nsec = 273000000;
4666 timer = malloc(sizeof(*timer));
4667 timer_init(timer);
4668 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4669 when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
4670 timer = malloc(sizeof(*timer));
4671 timer_init(timer);
4672 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4673 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4674 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4675 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4676 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4677 when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
4678 timer = malloc(sizeof(*timer));
4679 timer_init(timer);
4680 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4681 when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
4682 timer = malloc(sizeof(*timer));
4683 timer_init(timer);
4684 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4685 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4686 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4687 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4688 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4689 when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
4690 timer = malloc(sizeof(*timer));
4691 timer_init(timer);
4692 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4693 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
4694 timer = malloc(sizeof(*timer));
4695 timer_init(timer);
4696 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4697 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
4698 timer = malloc(sizeof(*timer));
4699 timer_init(timer);
4700 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4701 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
4702 timer = malloc(sizeof(*timer));
4703 timer_init(timer);
4704 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4705 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4706 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4707 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4708 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4709 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4710 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4711 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4712 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4713 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4714 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4715 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4716 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4717 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4718 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4719 when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000;
4720 timer = malloc(sizeof(*timer));
4721 timer_init(timer);
4722 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4723 when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
4724 timer = malloc(sizeof(*timer));
4725 timer_init(timer);
4726 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4727 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
4728 timer = malloc(sizeof(*timer));
4729 timer_init(timer);
4730 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4731 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4732 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4733 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4734 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4735 when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
4736 timer = malloc(sizeof(*timer));
4737 timer_init(timer);
4738 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4739 when.ts.tv_sec = 0; when.ts.tv_nsec = 317000000;
4740 timer = malloc(sizeof(*timer));
4741 timer_init(timer);
4742 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4745 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4746 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4747 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4748 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4749 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4750 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4751 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4752 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4753 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4754 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4755 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4756 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4757 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4758 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4759 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4760 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4761 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4762 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4763 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4764 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4765 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4766 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4767 when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
4768 timer = malloc(sizeof(*timer));
4769 timer_init(timer);
4770 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4771 when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
4772 timer = malloc(sizeof(*timer));
4773 timer_init(timer);
4774 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4775 when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
4776 timer = malloc(sizeof(*timer));
4777 timer_init(timer);
4778 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4779 when.ts.tv_sec = 0; when.ts.tv_nsec = 291000000;
4780 timer = malloc(sizeof(*timer));
4781 timer_init(timer);
4782 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4783 when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000;
4784 timer = malloc(sizeof(*timer));
4785 timer_init(timer);
4786 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4787 when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
4788 timer = malloc(sizeof(*timer));
4789 timer_init(timer);
4790 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4791 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
4792 timer = malloc(sizeof(*timer));
4793 timer_init(timer);
4794 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4795 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4796 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4797 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4798 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4799 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4800 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4801 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4802 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4803 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4804 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4805 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4806 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4807 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4808 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4809 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4810 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4811 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4812 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4813 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4814 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4815 when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000;
4816 timer = malloc(sizeof(*timer));
4817 timer_init(timer);
4818 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4819 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
4820 timer = malloc(sizeof(*timer));
4821 timer_init(timer);
4822 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4823 when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
4824 timer = malloc(sizeof(*timer));
4825 timer_init(timer);
4826 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4827 when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
4828 timer = malloc(sizeof(*timer));
4829 timer_init(timer);
4830 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4831 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4832 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4833 when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
4834 timer = malloc(sizeof(*timer));
4835 timer_init(timer);
4836 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4837 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
4838 timer = malloc(sizeof(*timer));
4839 timer_init(timer);
4840 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4841 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
4842 timer = malloc(sizeof(*timer));
4843 timer_init(timer);
4844 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4845 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4846 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4849 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4850 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4851 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4852 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4855 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4856 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4857 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4858 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4859 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4860 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4861 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4862 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4863 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4864 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4865 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4866 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4867 when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
4868 timer = malloc(sizeof(*timer));
4869 timer_init(timer);
4870 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4871 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
4872 timer = malloc(sizeof(*timer));
4873 timer_init(timer);
4874 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4875 when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
4876 timer = malloc(sizeof(*timer));
4877 timer_init(timer);
4878 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4879 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
4880 timer = malloc(sizeof(*timer));
4881 timer_init(timer);
4882 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4883 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4884 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4885 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4886 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4887 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4888 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4889 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4890 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4891 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4892 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4893 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
4894 timer = malloc(sizeof(*timer));
4895 timer_init(timer);
4896 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4897 when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
4898 timer = malloc(sizeof(*timer));
4899 timer_init(timer);
4900 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4901 when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000;
4902 timer = malloc(sizeof(*timer));
4903 timer_init(timer);
4904 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4905 when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
4906 timer = malloc(sizeof(*timer));
4907 timer_init(timer);
4908 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4909 when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000;
4910 timer = malloc(sizeof(*timer));
4911 timer_init(timer);
4912 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4913 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
4914 timer = malloc(sizeof(*timer));
4915 timer_init(timer);
4916 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4917 when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000;
4918 timer = malloc(sizeof(*timer));
4919 timer_init(timer);
4920 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4921 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4922 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4923 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
4924 timer = malloc(sizeof(*timer));
4925 timer_init(timer);
4926 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4927 when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
4928 timer = malloc(sizeof(*timer));
4929 timer_init(timer);
4930 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4931 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
4932 timer = malloc(sizeof(*timer));
4933 timer_init(timer);
4934 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4935 when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
4936 timer = malloc(sizeof(*timer));
4937 timer_init(timer);
4938 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4939 when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
4940 timer = malloc(sizeof(*timer));
4941 timer_init(timer);
4942 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4943 when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
4944 timer = malloc(sizeof(*timer));
4945 timer_init(timer);
4946 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4947 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4948 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4949 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4950 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4951 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4952 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4953 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4954 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4955 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4956 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4957 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4958 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4959 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4960 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4961 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4962 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4963 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4964 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4965 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4966 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4967 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
4968 timer = malloc(sizeof(*timer));
4969 timer_init(timer);
4970 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4971 when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
4972 timer = malloc(sizeof(*timer));
4973 timer_init(timer);
4974 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4975 when.ts.tv_sec = 0; when.ts.tv_nsec = 322000000;
4976 timer = malloc(sizeof(*timer));
4977 timer_init(timer);
4978 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4979 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
4980 timer = malloc(sizeof(*timer));
4981 timer_init(timer);
4982 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4983 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4984 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4985 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4986 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4987 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4988 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4989 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4990 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4991 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4992 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4993 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
4994 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
4995 when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
4996 timer = malloc(sizeof(*timer));
4997 timer_init(timer);
4998 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
4999 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
5000 timer = malloc(sizeof(*timer));
5001 timer_init(timer);
5002 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5003 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5004 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5005 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5006 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5007 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5008 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5009 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5010 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5011 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
5012 timer = malloc(sizeof(*timer));
5013 timer_init(timer);
5014 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5015 when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
5016 timer = malloc(sizeof(*timer));
5017 timer_init(timer);
5018 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5019 when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000;
5020 timer = malloc(sizeof(*timer));
5021 timer_init(timer);
5022 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5023 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
5024 timer = malloc(sizeof(*timer));
5025 timer_init(timer);
5026 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5027 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5028 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5029 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
5030 timer = malloc(sizeof(*timer));
5031 timer_init(timer);
5032 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5033 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
5034 timer = malloc(sizeof(*timer));
5035 timer_init(timer);
5036 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5037 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
5038 timer = malloc(sizeof(*timer));
5039 timer_init(timer);
5040 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5041 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
5042 timer = malloc(sizeof(*timer));
5043 timer_init(timer);
5044 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5045 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5046 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5047 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5048 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5049 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5050 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5051 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5052 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5053 when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
5054 timer = malloc(sizeof(*timer));
5055 timer_init(timer);
5056 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5057 when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000;
5058 timer = malloc(sizeof(*timer));
5059 timer_init(timer);
5060 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5061 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5062 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5063 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5064 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5065 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5066 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5067 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5068 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5069 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5070 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5071 when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
5072 timer = malloc(sizeof(*timer));
5073 timer_init(timer);
5074 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5075 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5076 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5077 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5078 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5079 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
5080 timer = malloc(sizeof(*timer));
5081 timer_init(timer);
5082 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5083 when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
5084 timer = malloc(sizeof(*timer));
5085 timer_init(timer);
5086 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5087 when.ts.tv_sec = 0; when.ts.tv_nsec = 321000000;
5088 timer = malloc(sizeof(*timer));
5089 timer_init(timer);
5090 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5091 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5092 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5093 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
5094 timer = malloc(sizeof(*timer));
5095 timer_init(timer);
5096 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5097 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
5098 timer = malloc(sizeof(*timer));
5099 timer_init(timer);
5100 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5101 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
5102 timer = malloc(sizeof(*timer));
5103 timer_init(timer);
5104 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5105 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5106 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5107 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5108 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5109 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5110 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5111 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5112 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5113 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5114 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5115 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5116 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5117 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5118 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5119 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5120 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5121 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5122 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5123 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5124 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5125 when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
5126 timer = malloc(sizeof(*timer));
5127 timer_init(timer);
5128 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5129 when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000;
5130 timer = malloc(sizeof(*timer));
5131 timer_init(timer);
5132 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5133 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
5134 timer = malloc(sizeof(*timer));
5135 timer_init(timer);
5136 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5137 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
5138 timer = malloc(sizeof(*timer));
5139 timer_init(timer);
5140 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5141 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5142 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5143 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5144 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5145 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5146 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5147 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5148 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5149 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5150 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5151 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5152 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5153 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5154 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5155 when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000;
5156 timer = malloc(sizeof(*timer));
5157 timer_init(timer);
5158 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5159 when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
5160 timer = malloc(sizeof(*timer));
5161 timer_init(timer);
5162 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5163 when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
5164 timer = malloc(sizeof(*timer));
5165 timer_init(timer);
5166 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5167 when.ts.tv_sec = 0; when.ts.tv_nsec = 290000000;
5168 timer = malloc(sizeof(*timer));
5169 timer_init(timer);
5170 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5171 when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
5172 timer = malloc(sizeof(*timer));
5173 timer_init(timer);
5174 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5175 when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000;
5176 timer = malloc(sizeof(*timer));
5177 timer_init(timer);
5178 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5179 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
5180 timer = malloc(sizeof(*timer));
5181 timer_init(timer);
5182 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5183 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5184 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5185 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5186 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5187 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5188 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5189 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5190 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5191 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5192 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5193 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5194 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5195 when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000;
5196 timer = malloc(sizeof(*timer));
5197 timer_init(timer);
5198 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5199 when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
5200 timer = malloc(sizeof(*timer));
5201 timer_init(timer);
5202 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5203 when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000;
5204 timer = malloc(sizeof(*timer));
5205 timer_init(timer);
5206 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5207 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5208 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5209 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5210 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5211 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5212 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5213 when.ts.tv_sec = 0; when.ts.tv_nsec = 282000000;
5214 timer = malloc(sizeof(*timer));
5215 timer_init(timer);
5216 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5217 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
5218 timer = malloc(sizeof(*timer));
5219 timer_init(timer);
5220 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5221 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
5222 timer = malloc(sizeof(*timer));
5223 timer_init(timer);
5224 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5225 when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
5226 timer = malloc(sizeof(*timer));
5227 timer_init(timer);
5228 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5229 when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
5230 timer = malloc(sizeof(*timer));
5231 timer_init(timer);
5232 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5233 when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000;
5234 timer = malloc(sizeof(*timer));
5235 timer_init(timer);
5236 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5237 when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
5238 timer = malloc(sizeof(*timer));
5239 timer_init(timer);
5240 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5241 when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000;
5242 timer = malloc(sizeof(*timer));
5243 timer_init(timer);
5244 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5245 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5246 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5247 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5248 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5249 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5250 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5251 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5252 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5253 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5254 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5255 when.ts.tv_sec = 0; when.ts.tv_nsec = 338000000;
5256 timer = malloc(sizeof(*timer));
5257 timer_init(timer);
5258 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5259 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
5260 timer = malloc(sizeof(*timer));
5261 timer_init(timer);
5262 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5263 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
5264 timer = malloc(sizeof(*timer));
5265 timer_init(timer);
5266 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5267 when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
5268 timer = malloc(sizeof(*timer));
5269 timer_init(timer);
5270 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5271 when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
5272 timer = malloc(sizeof(*timer));
5273 timer_init(timer);
5274 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5275 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
5276 timer = malloc(sizeof(*timer));
5277 timer_init(timer);
5278 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5279 when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000;
5280 timer = malloc(sizeof(*timer));
5281 timer_init(timer);
5282 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5283 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5284 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5285 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5286 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5287 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5288 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5289 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5290 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5291 when.ts.tv_sec = 0; when.ts.tv_nsec = 300000000;
5292 timer = malloc(sizeof(*timer));
5293 timer_init(timer);
5294 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5295 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5296 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5297 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5298 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5299 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5300 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5301 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5302 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5303 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5304 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5305 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5306 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5307 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5308 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5309 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5310 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5311 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5312 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5313 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5314 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5315 when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
5316 timer = malloc(sizeof(*timer));
5317 timer_init(timer);
5318 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5319 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
5320 timer = malloc(sizeof(*timer));
5321 timer_init(timer);
5322 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5323 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5324 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5325 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5326 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5327 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5328 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5329 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
5330 timer = malloc(sizeof(*timer));
5331 timer_init(timer);
5332 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5333 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5334 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5335 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5336 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5337 when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
5338 timer = malloc(sizeof(*timer));
5339 timer_init(timer);
5340 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5341 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
5342 timer = malloc(sizeof(*timer));
5343 timer_init(timer);
5344 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5345 when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
5346 timer = malloc(sizeof(*timer));
5347 timer_init(timer);
5348 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5349 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
5350 timer = malloc(sizeof(*timer));
5351 timer_init(timer);
5352 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5353 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5354 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5355 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5356 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5357 when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000;
5358 timer = malloc(sizeof(*timer));
5359 timer_init(timer);
5360 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5361 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
5362 timer = malloc(sizeof(*timer));
5363 timer_init(timer);
5364 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5365 when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
5366 timer = malloc(sizeof(*timer));
5367 timer_init(timer);
5368 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5369 when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
5370 timer = malloc(sizeof(*timer));
5371 timer_init(timer);
5372 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5373 when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000;
5374 timer = malloc(sizeof(*timer));
5375 timer_init(timer);
5376 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5377 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5378 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5379 when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
5380 timer = malloc(sizeof(*timer));
5381 timer_init(timer);
5382 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5383 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
5384 timer = malloc(sizeof(*timer));
5385 timer_init(timer);
5386 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5387 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
5388 timer = malloc(sizeof(*timer));
5389 timer_init(timer);
5390 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5391 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5392 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5393 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5394 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5395 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5396 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5397 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5398 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5399 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5400 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5401 when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
5402 timer = malloc(sizeof(*timer));
5403 timer_init(timer);
5404 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5405 when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000;
5406 timer = malloc(sizeof(*timer));
5407 timer_init(timer);
5408 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5409 when.ts.tv_sec = 0; when.ts.tv_nsec = 328000000;
5410 timer = malloc(sizeof(*timer));
5411 timer_init(timer);
5412 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5413 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5414 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5415 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
5416 timer = malloc(sizeof(*timer));
5417 timer_init(timer);
5418 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5419 when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000;
5420 timer = malloc(sizeof(*timer));
5421 timer_init(timer);
5422 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5423 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5424 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5425 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5426 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5427 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5428 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5429 when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000;
5430 timer = malloc(sizeof(*timer));
5431 timer_init(timer);
5432 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5433 when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
5434 timer = malloc(sizeof(*timer));
5435 timer_init(timer);
5436 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5437 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
5438 timer = malloc(sizeof(*timer));
5439 timer_init(timer);
5440 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5441 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
5442 timer = malloc(sizeof(*timer));
5443 timer_init(timer);
5444 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5445 when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000;
5446 timer = malloc(sizeof(*timer));
5447 timer_init(timer);
5448 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5449 when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
5450 timer = malloc(sizeof(*timer));
5451 timer_init(timer);
5452 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5453 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5454 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5455 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5456 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5457 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5458 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5459 when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000;
5460 timer = malloc(sizeof(*timer));
5461 timer_init(timer);
5462 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5463 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
5464 timer = malloc(sizeof(*timer));
5465 timer_init(timer);
5466 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5467 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5468 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5469 when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
5470 timer = malloc(sizeof(*timer));
5471 timer_init(timer);
5472 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5473 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5474 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5475 when.ts.tv_sec = 0; when.ts.tv_nsec = 243000000;
5476 timer = malloc(sizeof(*timer));
5477 timer_init(timer);
5478 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5479 when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
5480 timer = malloc(sizeof(*timer));
5481 timer_init(timer);
5482 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5483 when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000;
5484 timer = malloc(sizeof(*timer));
5485 timer_init(timer);
5486 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5487 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5488 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5489 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5490 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5491 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5492 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5493 when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000;
5494 timer = malloc(sizeof(*timer));
5495 timer_init(timer);
5496 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5497 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5498 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5499 when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
5500 timer = malloc(sizeof(*timer));
5501 timer_init(timer);
5502 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5503 when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
5504 timer = malloc(sizeof(*timer));
5505 timer_init(timer);
5506 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5507 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5508 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5509 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5510 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5511 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5512 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5513 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5514 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5515 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5516 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5517 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5518 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5519 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5520 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5521 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5522 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5523 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5524 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5525 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
5526 timer = malloc(sizeof(*timer));
5527 timer_init(timer);
5528 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5529 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
5530 timer = malloc(sizeof(*timer));
5531 timer_init(timer);
5532 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5533 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5534 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5535 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5536 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5537 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5538 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5539 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5540 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5541 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
5542 timer = malloc(sizeof(*timer));
5543 timer_init(timer);
5544 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5545 when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000;
5546 timer = malloc(sizeof(*timer));
5547 timer_init(timer);
5548 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5549 when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
5550 timer = malloc(sizeof(*timer));
5551 timer_init(timer);
5552 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5553 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5554 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5555 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5556 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5557 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5558 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5559 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5560 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5561 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5562 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5563 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5564 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5565 when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000;
5566 timer = malloc(sizeof(*timer));
5567 timer_init(timer);
5568 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5569 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5570 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5571 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5572 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5573 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5574 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5575 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5576 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5577 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5578 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5579 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5580 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5581 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5582 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5583 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5584 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5585 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5586 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5587 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5588 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5589 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5590 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5591 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5592 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5593 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5594 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5595 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5596 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5597 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5598 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5599 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5600 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5601 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5602 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5603 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5604 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5605 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5606 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5607 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5608 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5609 when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
5610 timer = malloc(sizeof(*timer));
5611 timer_init(timer);
5612 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5613 when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000;
5614 timer = malloc(sizeof(*timer));
5615 timer_init(timer);
5616 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5617 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
5618 timer = malloc(sizeof(*timer));
5619 timer_init(timer);
5620 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5621 when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
5622 timer = malloc(sizeof(*timer));
5623 timer_init(timer);
5624 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5625 when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
5626 timer = malloc(sizeof(*timer));
5627 timer_init(timer);
5628 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5629 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
5630 timer = malloc(sizeof(*timer));
5631 timer_init(timer);
5632 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5633 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5634 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5635 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5636 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5637 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5638 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5639 when.ts.tv_sec = 0; when.ts.tv_nsec = 323000000;
5640 timer = malloc(sizeof(*timer));
5641 timer_init(timer);
5642 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5643 when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000;
5644 timer = malloc(sizeof(*timer));
5645 timer_init(timer);
5646 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5647 when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000;
5648 timer = malloc(sizeof(*timer));
5649 timer_init(timer);
5650 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5651 when.ts.tv_sec = 0; when.ts.tv_nsec = 320000000;
5652 timer = malloc(sizeof(*timer));
5653 timer_init(timer);
5654 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5655 when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000;
5656 timer = malloc(sizeof(*timer));
5657 timer_init(timer);
5658 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5659 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5660 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5661 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5662 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5663 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5664 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5665 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5666 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5667 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5668 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5669 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5670 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5671 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5672 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5673 when.ts.tv_sec = 0; when.ts.tv_nsec = 351000000;
5674 timer = malloc(sizeof(*timer));
5675 timer_init(timer);
5676 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5677 when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
5678 timer = malloc(sizeof(*timer));
5679 timer_init(timer);
5680 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5681 when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
5682 timer = malloc(sizeof(*timer));
5683 timer_init(timer);
5684 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5685 when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000;
5686 timer = malloc(sizeof(*timer));
5687 timer_init(timer);
5688 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5689 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
5690 timer = malloc(sizeof(*timer));
5691 timer_init(timer);
5692 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5693 when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
5694 timer = malloc(sizeof(*timer));
5695 timer_init(timer);
5696 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5697 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5698 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5699 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5700 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5701 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5702 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5703 when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
5704 timer = malloc(sizeof(*timer));
5705 timer_init(timer);
5706 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5707 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
5708 timer = malloc(sizeof(*timer));
5709 timer_init(timer);
5710 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5711 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5712 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5713 when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
5714 timer = malloc(sizeof(*timer));
5715 timer_init(timer);
5716 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5717 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5718 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5719 when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000;
5720 timer = malloc(sizeof(*timer));
5721 timer_init(timer);
5722 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5723 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
5724 timer = malloc(sizeof(*timer));
5725 timer_init(timer);
5726 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5727 when.ts.tv_sec = 0; when.ts.tv_nsec = 319000000;
5728 timer = malloc(sizeof(*timer));
5729 timer_init(timer);
5730 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5731 when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
5732 timer = malloc(sizeof(*timer));
5733 timer_init(timer);
5734 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5735 when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
5736 timer = malloc(sizeof(*timer));
5737 timer_init(timer);
5738 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5739 when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
5740 timer = malloc(sizeof(*timer));
5741 timer_init(timer);
5742 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5743 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5744 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5745 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5746 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5747 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5748 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5749 when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
5750 timer = malloc(sizeof(*timer));
5751 timer_init(timer);
5752 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5753 when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000;
5754 timer = malloc(sizeof(*timer));
5755 timer_init(timer);
5756 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5757 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5758 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5759 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5760 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5761 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5762 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5763 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5764 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5765 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5766 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5767 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5768 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5769 when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000;
5770 timer = malloc(sizeof(*timer));
5771 timer_init(timer);
5772 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5773 when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000;
5774 timer = malloc(sizeof(*timer));
5775 timer_init(timer);
5776 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5777 when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000;
5778 timer = malloc(sizeof(*timer));
5779 timer_init(timer);
5780 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5781 when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000;
5782 timer = malloc(sizeof(*timer));
5783 timer_init(timer);
5784 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5785 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5786 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5787 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5788 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5789 when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
5790 timer = malloc(sizeof(*timer));
5791 timer_init(timer);
5792 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5793 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
5794 timer = malloc(sizeof(*timer));
5795 timer_init(timer);
5796 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5797 when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000;
5798 timer = malloc(sizeof(*timer));
5799 timer_init(timer);
5800 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5801 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5802 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5803 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5804 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5805 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5806 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5807 when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
5808 timer = malloc(sizeof(*timer));
5809 timer_init(timer);
5810 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5811 when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
5812 timer = malloc(sizeof(*timer));
5813 timer_init(timer);
5814 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5815 when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
5816 timer = malloc(sizeof(*timer));
5817 timer_init(timer);
5818 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5819 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
5820 timer = malloc(sizeof(*timer));
5821 timer_init(timer);
5822 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5823 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5824 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5825 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5826 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5827 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5828 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5829 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5830 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5831 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5832 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5833 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5834 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5835 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5836 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5837 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5838 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5839 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5840 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5841 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5842 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5843 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5844 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5845 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5846 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5847 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5848 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5849 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5850 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5851 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5852 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5853 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5854 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5855 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5856 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5857 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5858 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5859 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5860 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5861 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5862 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5863 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5864 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5865 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5866 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5867 when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
5868 timer = malloc(sizeof(*timer));
5869 timer_init(timer);
5870 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5871 when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
5872 timer = malloc(sizeof(*timer));
5873 timer_init(timer);
5874 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5875 when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
5876 timer = malloc(sizeof(*timer));
5877 timer_init(timer);
5878 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5879 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5880 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5881 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5882 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5883 when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
5884 timer = malloc(sizeof(*timer));
5885 timer_init(timer);
5886 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5887 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5888 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5889 when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
5890 timer = malloc(sizeof(*timer));
5891 timer_init(timer);
5892 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5893 when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
5894 timer = malloc(sizeof(*timer));
5895 timer_init(timer);
5896 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5897 when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
5898 timer = malloc(sizeof(*timer));
5899 timer_init(timer);
5900 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5901 when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000;
5902 timer = malloc(sizeof(*timer));
5903 timer_init(timer);
5904 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5905 when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
5906 timer = malloc(sizeof(*timer));
5907 timer_init(timer);
5908 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5909 when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
5910 timer = malloc(sizeof(*timer));
5911 timer_init(timer);
5912 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5913 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5914 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5915 when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
5916 timer = malloc(sizeof(*timer));
5917 timer_init(timer);
5918 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5919 when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
5920 timer = malloc(sizeof(*timer));
5921 timer_init(timer);
5922 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5923 when.ts.tv_sec = 0; when.ts.tv_nsec = 360000000;
5924 timer = malloc(sizeof(*timer));
5925 timer_init(timer);
5926 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5927 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5928 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5929 when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
5930 timer = malloc(sizeof(*timer));
5931 timer_init(timer);
5932 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5933 when.ts.tv_sec = 0; when.ts.tv_nsec = 349000000;
5934 timer = malloc(sizeof(*timer));
5935 timer_init(timer);
5936 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5937 when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000;
5938 timer = malloc(sizeof(*timer));
5939 timer_init(timer);
5940 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5941 when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000;
5942 timer = malloc(sizeof(*timer));
5943 timer_init(timer);
5944 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5945 when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000;
5946 timer = malloc(sizeof(*timer));
5947 timer_init(timer);
5948 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5949 when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
5950 timer = malloc(sizeof(*timer));
5951 timer_init(timer);
5952 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5953 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5954 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5955 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5956 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5957 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5958 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5959 when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
5960 timer = malloc(sizeof(*timer));
5961 timer_init(timer);
5962 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5963 when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000;
5964 timer = malloc(sizeof(*timer));
5965 timer_init(timer);
5966 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5967 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5968 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5969 when.ts.tv_sec = 0; when.ts.tv_nsec = 327000000;
5970 timer = malloc(sizeof(*timer));
5971 timer_init(timer);
5972 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5973 when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000;
5974 timer = malloc(sizeof(*timer));
5975 timer_init(timer);
5976 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5977 when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
5978 timer = malloc(sizeof(*timer));
5979 timer_init(timer);
5980 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5981 when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000;
5982 timer = malloc(sizeof(*timer));
5983 timer_init(timer);
5984 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
5985 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5986 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5987 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5988 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5989 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5990 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5991 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5992 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5993 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5994 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5995 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
5996 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
5997 when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
5998 timer = malloc(sizeof(*timer));
5999 timer_init(timer);
6000 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6001 when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
6002 timer = malloc(sizeof(*timer));
6003 timer_init(timer);
6004 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6005 when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000;
6006 timer = malloc(sizeof(*timer));
6007 timer_init(timer);
6008 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6009 when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000;
6010 timer = malloc(sizeof(*timer));
6011 timer_init(timer);
6012 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6013 when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000;
6014 timer = malloc(sizeof(*timer));
6015 timer_init(timer);
6016 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6017 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6018 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6019 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6020 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6021 when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000;
6022 timer = malloc(sizeof(*timer));
6023 timer_init(timer);
6024 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6025 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6026 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6027 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6028 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6029 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6030 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6031 when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000;
6032 timer = malloc(sizeof(*timer));
6033 timer_init(timer);
6034 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6035 when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000;
6036 timer = malloc(sizeof(*timer));
6037 timer_init(timer);
6038 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6039 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6040 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6041 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
6042 timer = malloc(sizeof(*timer));
6043 timer_init(timer);
6044 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6045 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6046 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6047 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6048 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6049 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6050 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6051 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6052 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6053 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6054 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6055 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6056 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6057 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6058 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6059 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6060 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6061 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6062 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6063 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6064 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6065 when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000;
6066 timer = malloc(sizeof(*timer));
6067 timer_init(timer);
6068 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6069 when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
6070 timer = malloc(sizeof(*timer));
6071 timer_init(timer);
6072 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6073 when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000;
6074 timer = malloc(sizeof(*timer));
6075 timer_init(timer);
6076 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6077 when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
6078 timer = malloc(sizeof(*timer));
6079 timer_init(timer);
6080 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6081 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6082 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6083 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6084 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6085 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6086 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6087 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6088 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6089 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6090 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6091 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6092 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6093 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6094 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6095 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6096 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6097 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6098 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6099 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6100 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6101 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6102 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6103 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6104 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6105 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6106 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6107 when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000;
6108 timer = malloc(sizeof(*timer));
6109 timer_init(timer);
6110 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6111 when.ts.tv_sec = 0; when.ts.tv_nsec = 314000000;
6112 timer = malloc(sizeof(*timer));
6113 timer_init(timer);
6114 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6115 when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
6116 timer = malloc(sizeof(*timer));
6117 timer_init(timer);
6118 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6119 when.ts.tv_sec = 0; when.ts.tv_nsec = 368000000;
6120 timer = malloc(sizeof(*timer));
6121 timer_init(timer);
6122 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6123 when.ts.tv_sec = 0; when.ts.tv_nsec = 335000000;
6124 timer = malloc(sizeof(*timer));
6125 timer_init(timer);
6126 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6127 when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
6128 timer = malloc(sizeof(*timer));
6129 timer_init(timer);
6130 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6131 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6132 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6133 when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
6134 timer = malloc(sizeof(*timer));
6135 timer_init(timer);
6136 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6137 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6138 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6139 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6140 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6141 when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000;
6142 timer = malloc(sizeof(*timer));
6143 timer_init(timer);
6144 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6145 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6146 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6147 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6148 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6149 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6150 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6151 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6152 free(timers_expire(&timers, when)); timers_check(&timers, "expire");
6153 when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000;
6154 timer = malloc(sizeof(*timer));
6155 timer_init(timer);
6156 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6157 when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000;
6158 timer = malloc(sizeof(*timer));
6159 timer_init(timer);
6160 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6161 when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
6162 timer = malloc(sizeof(*timer));
6163 timer_init(timer);
6164 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6165 when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000;
6166 timer = malloc(sizeof(*timer));
6167 timer_init(timer);
6168 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6169 when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000;
6170 timer = malloc(sizeof(*timer));
6171 timer_init(timer);
6172 timer_addmono(&timers, timer, when); timers_check(&timers, "add");
6173 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6174 timer_earliest(&timers, &when); timers_check(&timers, "earliest");
6175
6176 while (timer_earliest(&timers, &when)) {
6177 free(timers_expire(&timers, when));
6178 }
6179
6180 ok1(timers_check(&timers, NULL));
6181 timers_cleanup(&timers);
6182
6183 return exit_status();
6184 }
6185