git.ozlabs.org Git - ccan/blob - ccan/timer/test/run-corrupt2.c

   1 #define CCAN_TIMER_DEBUG 1
   2 #include <ccan/timer/timer.h>
   3 /* Include the C files directly. */
   4 #include <ccan/timer/timer.c>
   5 #include <ccan/tap/tap.h>
   6
   7 /* This is the original pre-cut-down dump. */
   8 int main(int argc, char *argv[])
   9 {
  10         struct timemono when;
  11         struct timers timers;
  12         struct timer *timer;
  13
  14         plan_tests(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 }