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 timeabs 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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&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_add(&timers, timer, when); timers_check(&timers, "add");
1627         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1628         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1629         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1630         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1631         when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1632         timer = malloc(sizeof(*timer));
1633         timer_init(timer);
1634         timer_add(&timers, timer, when); timers_check(&timers, "add");
1635         when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000;
1636         timer = malloc(sizeof(*timer));
1637         timer_init(timer);
1638         timer_add(&timers, timer, when); timers_check(&timers, "add");
1639         when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1640         timer = malloc(sizeof(*timer));
1641         timer_init(timer);
1642         timer_add(&timers, timer, when); timers_check(&timers, "add");
1643         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1644         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1645         when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000;
1646         timer = malloc(sizeof(*timer));
1647         timer_init(timer);
1648         timer_add(&timers, timer, when); timers_check(&timers, "add");
1649         when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
1650         timer = malloc(sizeof(*timer));
1651         timer_init(timer);
1652         timer_add(&timers, timer, when); timers_check(&timers, "add");
1653         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1654         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1655         when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
1656         timer = malloc(sizeof(*timer));
1657         timer_init(timer);
1658         timer_add(&timers, timer, when); timers_check(&timers, "add");
1659         when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
1660         timer = malloc(sizeof(*timer));
1661         timer_init(timer);
1662         timer_add(&timers, timer, when); timers_check(&timers, "add");
1663         when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
1664         timer = malloc(sizeof(*timer));
1665         timer_init(timer);
1666         timer_add(&timers, timer, when); timers_check(&timers, "add");
1667         when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000;
1668         timer = malloc(sizeof(*timer));
1669         timer_init(timer);
1670         timer_add(&timers, timer, when); timers_check(&timers, "add");
1671         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1672         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1673         when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1674         timer = malloc(sizeof(*timer));
1675         timer_init(timer);
1676         timer_add(&timers, timer, when); timers_check(&timers, "add");
1677         when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
1678         timer = malloc(sizeof(*timer));
1679         timer_init(timer);
1680         timer_add(&timers, timer, when); timers_check(&timers, "add");
1681         when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1682         timer = malloc(sizeof(*timer));
1683         timer_init(timer);
1684         timer_add(&timers, timer, when); timers_check(&timers, "add");
1685         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1686         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1687         when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
1688         timer = malloc(sizeof(*timer));
1689         timer_init(timer);
1690         timer_add(&timers, timer, when); timers_check(&timers, "add");
1691         when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1692         timer = malloc(sizeof(*timer));
1693         timer_init(timer);
1694         timer_add(&timers, timer, when); timers_check(&timers, "add");
1695         when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
1696         timer = malloc(sizeof(*timer));
1697         timer_init(timer);
1698         timer_add(&timers, timer, when); timers_check(&timers, "add");
1699         when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1700         timer = malloc(sizeof(*timer));
1701         timer_init(timer);
1702         timer_add(&timers, timer, when); timers_check(&timers, "add");
1703         when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000;
1704         timer = malloc(sizeof(*timer));
1705         timer_init(timer);
1706         timer_add(&timers, timer, when); timers_check(&timers, "add");
1707         when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1708         timer = malloc(sizeof(*timer));
1709         timer_init(timer);
1710         timer_add(&timers, timer, when); timers_check(&timers, "add");
1711         when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
1712         timer = malloc(sizeof(*timer));
1713         timer_init(timer);
1714         timer_add(&timers, timer, when); timers_check(&timers, "add");
1715         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1716         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1717         when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000;
1718         timer = malloc(sizeof(*timer));
1719         timer_init(timer);
1720         timer_add(&timers, timer, when); timers_check(&timers, "add");
1721         when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000;
1722         timer = malloc(sizeof(*timer));
1723         timer_init(timer);
1724         timer_add(&timers, timer, when); timers_check(&timers, "add");
1725         when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
1726         timer = malloc(sizeof(*timer));
1727         timer_init(timer);
1728         timer_add(&timers, timer, when); timers_check(&timers, "add");
1729         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1730         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1731         when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1732         timer = malloc(sizeof(*timer));
1733         timer_init(timer);
1734         timer_add(&timers, timer, when); timers_check(&timers, "add");
1735         when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
1736         timer = malloc(sizeof(*timer));
1737         timer_init(timer);
1738         timer_add(&timers, timer, when); timers_check(&timers, "add");
1739         when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000;
1740         timer = malloc(sizeof(*timer));
1741         timer_init(timer);
1742         timer_add(&timers, timer, when); timers_check(&timers, "add");
1743         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1744         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1745         when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
1746         timer = malloc(sizeof(*timer));
1747         timer_init(timer);
1748         timer_add(&timers, timer, when); timers_check(&timers, "add");
1749         when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1750         timer = malloc(sizeof(*timer));
1751         timer_init(timer);
1752         timer_add(&timers, timer, when); timers_check(&timers, "add");
1753         when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
1754         timer = malloc(sizeof(*timer));
1755         timer_init(timer);
1756         timer_add(&timers, timer, when); timers_check(&timers, "add");
1757         when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
1758         timer = malloc(sizeof(*timer));
1759         timer_init(timer);
1760         timer_add(&timers, timer, when); timers_check(&timers, "add");
1761         when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1762         timer = malloc(sizeof(*timer));
1763         timer_init(timer);
1764         timer_add(&timers, timer, when); timers_check(&timers, "add");
1765         when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
1766         timer = malloc(sizeof(*timer));
1767         timer_init(timer);
1768         timer_add(&timers, timer, when); timers_check(&timers, "add");
1769         when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1770         timer = malloc(sizeof(*timer));
1771         timer_init(timer);
1772         timer_add(&timers, timer, when); timers_check(&timers, "add");
1773         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1774         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1775         when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1776         timer = malloc(sizeof(*timer));
1777         timer_init(timer);
1778         timer_add(&timers, timer, when); timers_check(&timers, "add");
1779         when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000;
1780         timer = malloc(sizeof(*timer));
1781         timer_init(timer);
1782         timer_add(&timers, timer, when); timers_check(&timers, "add");
1783         when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
1784         timer = malloc(sizeof(*timer));
1785         timer_init(timer);
1786         timer_add(&timers, timer, when); timers_check(&timers, "add");
1787         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1788         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1789         when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
1790         timer = malloc(sizeof(*timer));
1791         timer_init(timer);
1792         timer_add(&timers, timer, when); timers_check(&timers, "add");
1793         when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1794         timer = malloc(sizeof(*timer));
1795         timer_init(timer);
1796         timer_add(&timers, timer, when); timers_check(&timers, "add");
1797         when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000;
1798         timer = malloc(sizeof(*timer));
1799         timer_init(timer);
1800         timer_add(&timers, timer, when); timers_check(&timers, "add");
1801         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1802         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1803         when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000;
1804         timer = malloc(sizeof(*timer));
1805         timer_init(timer);
1806         timer_add(&timers, timer, when); timers_check(&timers, "add");
1807         when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
1808         timer = malloc(sizeof(*timer));
1809         timer_init(timer);
1810         timer_add(&timers, timer, when); timers_check(&timers, "add");
1811         when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000;
1812         timer = malloc(sizeof(*timer));
1813         timer_init(timer);
1814         timer_add(&timers, timer, when); timers_check(&timers, "add");
1815         when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
1816         timer = malloc(sizeof(*timer));
1817         timer_init(timer);
1818         timer_add(&timers, timer, when); timers_check(&timers, "add");
1819         when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
1820         timer = malloc(sizeof(*timer));
1821         timer_init(timer);
1822         timer_add(&timers, timer, when); timers_check(&timers, "add");
1823         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1824         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1825         when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
1826         timer = malloc(sizeof(*timer));
1827         timer_init(timer);
1828         timer_add(&timers, timer, when); timers_check(&timers, "add");
1829         when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1830         timer = malloc(sizeof(*timer));
1831         timer_init(timer);
1832         timer_add(&timers, timer, when); timers_check(&timers, "add");
1833         when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
1834         timer = malloc(sizeof(*timer));
1835         timer_init(timer);
1836         timer_add(&timers, timer, when); timers_check(&timers, "add");
1837         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1838         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1839         when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000;
1840         timer = malloc(sizeof(*timer));
1841         timer_init(timer);
1842         timer_add(&timers, timer, when); timers_check(&timers, "add");
1843         when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
1844         timer = malloc(sizeof(*timer));
1845         timer_init(timer);
1846         timer_add(&timers, timer, when); timers_check(&timers, "add");
1847         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1848         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1849         when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000;
1850         timer = malloc(sizeof(*timer));
1851         timer_init(timer);
1852         timer_add(&timers, timer, when); timers_check(&timers, "add");
1853         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1854         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1855         when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
1856         timer = malloc(sizeof(*timer));
1857         timer_init(timer);
1858         timer_add(&timers, timer, when); timers_check(&timers, "add");
1859         when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1860         timer = malloc(sizeof(*timer));
1861         timer_init(timer);
1862         timer_add(&timers, timer, when); timers_check(&timers, "add");
1863         when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
1864         timer = malloc(sizeof(*timer));
1865         timer_init(timer);
1866         timer_add(&timers, timer, when); timers_check(&timers, "add");
1867         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1868         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1869         when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1870         timer = malloc(sizeof(*timer));
1871         timer_init(timer);
1872         timer_add(&timers, timer, when); timers_check(&timers, "add");
1873         when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
1874         timer = malloc(sizeof(*timer));
1875         timer_init(timer);
1876         timer_add(&timers, timer, when); timers_check(&timers, "add");
1877         when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
1878         timer = malloc(sizeof(*timer));
1879         timer_init(timer);
1880         timer_add(&timers, timer, when); timers_check(&timers, "add");
1881         when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
1882         timer = malloc(sizeof(*timer));
1883         timer_init(timer);
1884         timer_add(&timers, timer, when); timers_check(&timers, "add");
1885         when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
1886         timer = malloc(sizeof(*timer));
1887         timer_init(timer);
1888         timer_add(&timers, timer, when); timers_check(&timers, "add");
1889         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1890         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1891         when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
1892         timer = malloc(sizeof(*timer));
1893         timer_init(timer);
1894         timer_add(&timers, timer, when); timers_check(&timers, "add");
1895         when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
1896         timer = malloc(sizeof(*timer));
1897         timer_init(timer);
1898         timer_add(&timers, timer, when); timers_check(&timers, "add");
1899         when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
1900         timer = malloc(sizeof(*timer));
1901         timer_init(timer);
1902         timer_add(&timers, timer, when); timers_check(&timers, "add");
1903         when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
1904         timer = malloc(sizeof(*timer));
1905         timer_init(timer);
1906         timer_add(&timers, timer, when); timers_check(&timers, "add");
1907         when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000;
1908         timer = malloc(sizeof(*timer));
1909         timer_init(timer);
1910         timer_add(&timers, timer, when); timers_check(&timers, "add");
1911         when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
1912         timer = malloc(sizeof(*timer));
1913         timer_init(timer);
1914         timer_add(&timers, timer, when); timers_check(&timers, "add");
1915         when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
1916         timer = malloc(sizeof(*timer));
1917         timer_init(timer);
1918         timer_add(&timers, timer, when); timers_check(&timers, "add");
1919         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1920         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1921         when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1922         timer = malloc(sizeof(*timer));
1923         timer_init(timer);
1924         timer_add(&timers, timer, when); timers_check(&timers, "add");
1925         when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
1926         timer = malloc(sizeof(*timer));
1927         timer_init(timer);
1928         timer_add(&timers, timer, when); timers_check(&timers, "add");
1929         when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000;
1930         timer = malloc(sizeof(*timer));
1931         timer_init(timer);
1932         timer_add(&timers, timer, when); timers_check(&timers, "add");
1933         when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000;
1934         timer = malloc(sizeof(*timer));
1935         timer_init(timer);
1936         timer_add(&timers, timer, when); timers_check(&timers, "add");
1937         when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000;
1938         timer = malloc(sizeof(*timer));
1939         timer_init(timer);
1940         timer_add(&timers, timer, when); timers_check(&timers, "add");
1941         when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
1942         timer = malloc(sizeof(*timer));
1943         timer_init(timer);
1944         timer_add(&timers, timer, when); timers_check(&timers, "add");
1945         when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
1946         timer = malloc(sizeof(*timer));
1947         timer_init(timer);
1948         timer_add(&timers, timer, when); timers_check(&timers, "add");
1949         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1950         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1951         when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
1952         timer = malloc(sizeof(*timer));
1953         timer_init(timer);
1954         timer_add(&timers, timer, when); timers_check(&timers, "add");
1955         when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000;
1956         timer = malloc(sizeof(*timer));
1957         timer_init(timer);
1958         timer_add(&timers, timer, when); timers_check(&timers, "add");
1959         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1960         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1961         when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
1962         timer = malloc(sizeof(*timer));
1963         timer_init(timer);
1964         timer_add(&timers, timer, when); timers_check(&timers, "add");
1965         when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
1966         timer = malloc(sizeof(*timer));
1967         timer_init(timer);
1968         timer_add(&timers, timer, when); timers_check(&timers, "add");
1969         when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000;
1970         timer = malloc(sizeof(*timer));
1971         timer_init(timer);
1972         timer_add(&timers, timer, when); timers_check(&timers, "add");
1973         when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000;
1974         timer = malloc(sizeof(*timer));
1975         timer_init(timer);
1976         timer_add(&timers, timer, when); timers_check(&timers, "add");
1977         when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
1978         timer = malloc(sizeof(*timer));
1979         timer_init(timer);
1980         timer_add(&timers, timer, when); timers_check(&timers, "add");
1981         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1982         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1983         when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
1984         timer = malloc(sizeof(*timer));
1985         timer_init(timer);
1986         timer_add(&timers, timer, when); timers_check(&timers, "add");
1987         when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
1988         timer = malloc(sizeof(*timer));
1989         timer_init(timer);
1990         timer_add(&timers, timer, when); timers_check(&timers, "add");
1991         when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
1992         timer = malloc(sizeof(*timer));
1993         timer_init(timer);
1994         timer_add(&timers, timer, when); timers_check(&timers, "add");
1995         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
1996         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
1997         when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
1998         timer = malloc(sizeof(*timer));
1999         timer_init(timer);
2000         timer_add(&timers, timer, when); timers_check(&timers, "add");
2001         when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2002         timer = malloc(sizeof(*timer));
2003         timer_init(timer);
2004         timer_add(&timers, timer, when); timers_check(&timers, "add");
2005         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2006         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2007         when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000;
2008         timer = malloc(sizeof(*timer));
2009         timer_init(timer);
2010         timer_add(&timers, timer, when); timers_check(&timers, "add");
2011         when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000;
2012         timer = malloc(sizeof(*timer));
2013         timer_init(timer);
2014         timer_add(&timers, timer, when); timers_check(&timers, "add");
2015         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2016         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2017         when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2018         timer = malloc(sizeof(*timer));
2019         timer_init(timer);
2020         timer_add(&timers, timer, when); timers_check(&timers, "add");
2021         when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2022         timer = malloc(sizeof(*timer));
2023         timer_init(timer);
2024         timer_add(&timers, timer, when); timers_check(&timers, "add");
2025         when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
2026         timer = malloc(sizeof(*timer));
2027         timer_init(timer);
2028         timer_add(&timers, timer, when); timers_check(&timers, "add");
2029         when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
2030         timer = malloc(sizeof(*timer));
2031         timer_init(timer);
2032         timer_add(&timers, timer, when); timers_check(&timers, "add");
2033         when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000;
2034         timer = malloc(sizeof(*timer));
2035         timer_init(timer);
2036         timer_add(&timers, timer, when); timers_check(&timers, "add");
2037         when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2038         timer = malloc(sizeof(*timer));
2039         timer_init(timer);
2040         timer_add(&timers, timer, when); timers_check(&timers, "add");
2041         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2042         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2043         when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2044         timer = malloc(sizeof(*timer));
2045         timer_init(timer);
2046         timer_add(&timers, timer, when); timers_check(&timers, "add");
2047         when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2048         timer = malloc(sizeof(*timer));
2049         timer_init(timer);
2050         timer_add(&timers, timer, when); timers_check(&timers, "add");
2051         when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2052         timer = malloc(sizeof(*timer));
2053         timer_init(timer);
2054         timer_add(&timers, timer, when); timers_check(&timers, "add");
2055         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2056         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2057         when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2058         timer = malloc(sizeof(*timer));
2059         timer_init(timer);
2060         timer_add(&timers, timer, when); timers_check(&timers, "add");
2061         when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2062         timer = malloc(sizeof(*timer));
2063         timer_init(timer);
2064         timer_add(&timers, timer, when); timers_check(&timers, "add");
2065         when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2066         timer = malloc(sizeof(*timer));
2067         timer_init(timer);
2068         timer_add(&timers, timer, when); timers_check(&timers, "add");
2069         when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2070         timer = malloc(sizeof(*timer));
2071         timer_init(timer);
2072         timer_add(&timers, timer, when); timers_check(&timers, "add");
2073         when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
2074         timer = malloc(sizeof(*timer));
2075         timer_init(timer);
2076         timer_add(&timers, timer, when); timers_check(&timers, "add");
2077         when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2078         timer = malloc(sizeof(*timer));
2079         timer_init(timer);
2080         timer_add(&timers, timer, when); timers_check(&timers, "add");
2081         when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000;
2082         timer = malloc(sizeof(*timer));
2083         timer_init(timer);
2084         timer_add(&timers, timer, when); timers_check(&timers, "add");
2085         when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
2086         timer = malloc(sizeof(*timer));
2087         timer_init(timer);
2088         timer_add(&timers, timer, when); timers_check(&timers, "add");
2089         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2090         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2091         when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2092         timer = malloc(sizeof(*timer));
2093         timer_init(timer);
2094         timer_add(&timers, timer, when); timers_check(&timers, "add");
2095         when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000;
2096         timer = malloc(sizeof(*timer));
2097         timer_init(timer);
2098         timer_add(&timers, timer, when); timers_check(&timers, "add");
2099         when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2100         timer = malloc(sizeof(*timer));
2101         timer_init(timer);
2102         timer_add(&timers, timer, when); timers_check(&timers, "add");
2103         when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2104         timer = malloc(sizeof(*timer));
2105         timer_init(timer);
2106         timer_add(&timers, timer, when); timers_check(&timers, "add");
2107         when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2108         timer = malloc(sizeof(*timer));
2109         timer_init(timer);
2110         timer_add(&timers, timer, when); timers_check(&timers, "add");
2111         when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2112         timer = malloc(sizeof(*timer));
2113         timer_init(timer);
2114         timer_add(&timers, timer, when); timers_check(&timers, "add");
2115         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2116         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2117         when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2118         timer = malloc(sizeof(*timer));
2119         timer_init(timer);
2120         timer_add(&timers, timer, when); timers_check(&timers, "add");
2121         when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000;
2122         timer = malloc(sizeof(*timer));
2123         timer_init(timer);
2124         timer_add(&timers, timer, when); timers_check(&timers, "add");
2125         when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2126         timer = malloc(sizeof(*timer));
2127         timer_init(timer);
2128         timer_add(&timers, timer, when); timers_check(&timers, "add");
2129         when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2130         timer = malloc(sizeof(*timer));
2131         timer_init(timer);
2132         timer_add(&timers, timer, when); timers_check(&timers, "add");
2133         when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
2134         timer = malloc(sizeof(*timer));
2135         timer_init(timer);
2136         timer_add(&timers, timer, when); timers_check(&timers, "add");
2137         when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2138         timer = malloc(sizeof(*timer));
2139         timer_init(timer);
2140         timer_add(&timers, timer, when); timers_check(&timers, "add");
2141         when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000;
2142         timer = malloc(sizeof(*timer));
2143         timer_init(timer);
2144         timer_add(&timers, timer, when); timers_check(&timers, "add");
2145         when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000;
2146         timer = malloc(sizeof(*timer));
2147         timer_init(timer);
2148         timer_add(&timers, timer, when); timers_check(&timers, "add");
2149         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2150         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2151         when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2152         timer = malloc(sizeof(*timer));
2153         timer_init(timer);
2154         timer_add(&timers, timer, when); timers_check(&timers, "add");
2155         when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
2156         timer = malloc(sizeof(*timer));
2157         timer_init(timer);
2158         timer_add(&timers, timer, when); timers_check(&timers, "add");
2159         when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000;
2160         timer = malloc(sizeof(*timer));
2161         timer_init(timer);
2162         timer_add(&timers, timer, when); timers_check(&timers, "add");
2163         when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2164         timer = malloc(sizeof(*timer));
2165         timer_init(timer);
2166         timer_add(&timers, timer, when); timers_check(&timers, "add");
2167         when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
2168         timer = malloc(sizeof(*timer));
2169         timer_init(timer);
2170         timer_add(&timers, timer, when); timers_check(&timers, "add");
2171         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2172         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2173         when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2174         timer = malloc(sizeof(*timer));
2175         timer_init(timer);
2176         timer_add(&timers, timer, when); timers_check(&timers, "add");
2177         when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2178         timer = malloc(sizeof(*timer));
2179         timer_init(timer);
2180         timer_add(&timers, timer, when); timers_check(&timers, "add");
2181         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2182         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2183         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2184         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2185         when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000;
2186         timer = malloc(sizeof(*timer));
2187         timer_init(timer);
2188         timer_add(&timers, timer, when); timers_check(&timers, "add");
2189         when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2190         timer = malloc(sizeof(*timer));
2191         timer_init(timer);
2192         timer_add(&timers, timer, when); timers_check(&timers, "add");
2193         when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2194         timer = malloc(sizeof(*timer));
2195         timer_init(timer);
2196         timer_add(&timers, timer, when); timers_check(&timers, "add");
2197         when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2198         timer = malloc(sizeof(*timer));
2199         timer_init(timer);
2200         timer_add(&timers, timer, when); timers_check(&timers, "add");
2201         when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
2202         timer = malloc(sizeof(*timer));
2203         timer_init(timer);
2204         timer_add(&timers, timer, when); timers_check(&timers, "add");
2205         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2206         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2207         when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000;
2208         timer = malloc(sizeof(*timer));
2209         timer_init(timer);
2210         timer_add(&timers, timer, when); timers_check(&timers, "add");
2211         when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
2212         timer = malloc(sizeof(*timer));
2213         timer_init(timer);
2214         timer_add(&timers, timer, when); timers_check(&timers, "add");
2215         when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2216         timer = malloc(sizeof(*timer));
2217         timer_init(timer);
2218         timer_add(&timers, timer, when); timers_check(&timers, "add");
2219         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2220         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2221         when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000;
2222         timer = malloc(sizeof(*timer));
2223         timer_init(timer);
2224         timer_add(&timers, timer, when); timers_check(&timers, "add");
2225         when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000;
2226         timer = malloc(sizeof(*timer));
2227         timer_init(timer);
2228         timer_add(&timers, timer, when); timers_check(&timers, "add");
2229         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2230         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2231         when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000;
2232         timer = malloc(sizeof(*timer));
2233         timer_init(timer);
2234         timer_add(&timers, timer, when); timers_check(&timers, "add");
2235         when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2236         timer = malloc(sizeof(*timer));
2237         timer_init(timer);
2238         timer_add(&timers, timer, when); timers_check(&timers, "add");
2239         when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000;
2240         timer = malloc(sizeof(*timer));
2241         timer_init(timer);
2242         timer_add(&timers, timer, when); timers_check(&timers, "add");
2243         when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2244         timer = malloc(sizeof(*timer));
2245         timer_init(timer);
2246         timer_add(&timers, timer, when); timers_check(&timers, "add");
2247         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2248         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2249         when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2250         timer = malloc(sizeof(*timer));
2251         timer_init(timer);
2252         timer_add(&timers, timer, when); timers_check(&timers, "add");
2253         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2254         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2255         when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000;
2256         timer = malloc(sizeof(*timer));
2257         timer_init(timer);
2258         timer_add(&timers, timer, when); timers_check(&timers, "add");
2259         when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2260         timer = malloc(sizeof(*timer));
2261         timer_init(timer);
2262         timer_add(&timers, timer, when); timers_check(&timers, "add");
2263         when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2264         timer = malloc(sizeof(*timer));
2265         timer_init(timer);
2266         timer_add(&timers, timer, when); timers_check(&timers, "add");
2267         when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
2268         timer = malloc(sizeof(*timer));
2269         timer_init(timer);
2270         timer_add(&timers, timer, when); timers_check(&timers, "add");
2271         when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2272         timer = malloc(sizeof(*timer));
2273         timer_init(timer);
2274         timer_add(&timers, timer, when); timers_check(&timers, "add");
2275         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2276         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2277         when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2278         timer = malloc(sizeof(*timer));
2279         timer_init(timer);
2280         timer_add(&timers, timer, when); timers_check(&timers, "add");
2281         when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2282         timer = malloc(sizeof(*timer));
2283         timer_init(timer);
2284         timer_add(&timers, timer, when); timers_check(&timers, "add");
2285         when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
2286         timer = malloc(sizeof(*timer));
2287         timer_init(timer);
2288         timer_add(&timers, timer, when); timers_check(&timers, "add");
2289         when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2290         timer = malloc(sizeof(*timer));
2291         timer_init(timer);
2292         timer_add(&timers, timer, when); timers_check(&timers, "add");
2293         when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2294         timer = malloc(sizeof(*timer));
2295         timer_init(timer);
2296         timer_add(&timers, timer, when); timers_check(&timers, "add");
2297         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2298         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2299         when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000;
2300         timer = malloc(sizeof(*timer));
2301         timer_init(timer);
2302         timer_add(&timers, timer, when); timers_check(&timers, "add");
2303         when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000;
2304         timer = malloc(sizeof(*timer));
2305         timer_init(timer);
2306         timer_add(&timers, timer, when); timers_check(&timers, "add");
2307         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2308         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2309         when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2310         timer = malloc(sizeof(*timer));
2311         timer_init(timer);
2312         timer_add(&timers, timer, when); timers_check(&timers, "add");
2313         when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
2314         timer = malloc(sizeof(*timer));
2315         timer_init(timer);
2316         timer_add(&timers, timer, when); timers_check(&timers, "add");
2317         when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2318         timer = malloc(sizeof(*timer));
2319         timer_init(timer);
2320         timer_add(&timers, timer, when); timers_check(&timers, "add");
2321         when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2322         timer = malloc(sizeof(*timer));
2323         timer_init(timer);
2324         timer_add(&timers, timer, when); timers_check(&timers, "add");
2325         when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000;
2326         timer = malloc(sizeof(*timer));
2327         timer_init(timer);
2328         timer_add(&timers, timer, when); timers_check(&timers, "add");
2329         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2330         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2331         when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
2332         timer = malloc(sizeof(*timer));
2333         timer_init(timer);
2334         timer_add(&timers, timer, when); timers_check(&timers, "add");
2335         when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2336         timer = malloc(sizeof(*timer));
2337         timer_init(timer);
2338         timer_add(&timers, timer, when); timers_check(&timers, "add");
2339         when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2340         timer = malloc(sizeof(*timer));
2341         timer_init(timer);
2342         timer_add(&timers, timer, when); timers_check(&timers, "add");
2343         when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000;
2344         timer = malloc(sizeof(*timer));
2345         timer_init(timer);
2346         timer_add(&timers, timer, when); timers_check(&timers, "add");
2347         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2348         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2349         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2350         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2351         when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2352         timer = malloc(sizeof(*timer));
2353         timer_init(timer);
2354         timer_add(&timers, timer, when); timers_check(&timers, "add");
2355         when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2356         timer = malloc(sizeof(*timer));
2357         timer_init(timer);
2358         timer_add(&timers, timer, when); timers_check(&timers, "add");
2359         when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000;
2360         timer = malloc(sizeof(*timer));
2361         timer_init(timer);
2362         timer_add(&timers, timer, when); timers_check(&timers, "add");
2363         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2364         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2365         when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2366         timer = malloc(sizeof(*timer));
2367         timer_init(timer);
2368         timer_add(&timers, timer, when); timers_check(&timers, "add");
2369         when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2370         timer = malloc(sizeof(*timer));
2371         timer_init(timer);
2372         timer_add(&timers, timer, when); timers_check(&timers, "add");
2373         when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2374         timer = malloc(sizeof(*timer));
2375         timer_init(timer);
2376         timer_add(&timers, timer, when); timers_check(&timers, "add");
2377         when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2378         timer = malloc(sizeof(*timer));
2379         timer_init(timer);
2380         timer_add(&timers, timer, when); timers_check(&timers, "add");
2381         when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000;
2382         timer = malloc(sizeof(*timer));
2383         timer_init(timer);
2384         timer_add(&timers, timer, when); timers_check(&timers, "add");
2385         when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2386         timer = malloc(sizeof(*timer));
2387         timer_init(timer);
2388         timer_add(&timers, timer, when); timers_check(&timers, "add");
2389         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2390         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2391         when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000;
2392         timer = malloc(sizeof(*timer));
2393         timer_init(timer);
2394         timer_add(&timers, timer, when); timers_check(&timers, "add");
2395         when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000;
2396         timer = malloc(sizeof(*timer));
2397         timer_init(timer);
2398         timer_add(&timers, timer, when); timers_check(&timers, "add");
2399         when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
2400         timer = malloc(sizeof(*timer));
2401         timer_init(timer);
2402         timer_add(&timers, timer, when); timers_check(&timers, "add");
2403         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2404         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2405         when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2406         timer = malloc(sizeof(*timer));
2407         timer_init(timer);
2408         timer_add(&timers, timer, when); timers_check(&timers, "add");
2409         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2410         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2411         when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2412         timer = malloc(sizeof(*timer));
2413         timer_init(timer);
2414         timer_add(&timers, timer, when); timers_check(&timers, "add");
2415         when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
2416         timer = malloc(sizeof(*timer));
2417         timer_init(timer);
2418         timer_add(&timers, timer, when); timers_check(&timers, "add");
2419         when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2420         timer = malloc(sizeof(*timer));
2421         timer_init(timer);
2422         timer_add(&timers, timer, when); timers_check(&timers, "add");
2423         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2424         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2425         when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2426         timer = malloc(sizeof(*timer));
2427         timer_init(timer);
2428         timer_add(&timers, timer, when); timers_check(&timers, "add");
2429         when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000;
2430         timer = malloc(sizeof(*timer));
2431         timer_init(timer);
2432         timer_add(&timers, timer, when); timers_check(&timers, "add");
2433         when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2434         timer = malloc(sizeof(*timer));
2435         timer_init(timer);
2436         timer_add(&timers, timer, when); timers_check(&timers, "add");
2437         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2438         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2439         when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
2440         timer = malloc(sizeof(*timer));
2441         timer_init(timer);
2442         timer_add(&timers, timer, when); timers_check(&timers, "add");
2443         when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000;
2444         timer = malloc(sizeof(*timer));
2445         timer_init(timer);
2446         timer_add(&timers, timer, when); timers_check(&timers, "add");
2447         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2448         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2449         when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2450         timer = malloc(sizeof(*timer));
2451         timer_init(timer);
2452         timer_add(&timers, timer, when); timers_check(&timers, "add");
2453         when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
2454         timer = malloc(sizeof(*timer));
2455         timer_init(timer);
2456         timer_add(&timers, timer, when); timers_check(&timers, "add");
2457         when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2458         timer = malloc(sizeof(*timer));
2459         timer_init(timer);
2460         timer_add(&timers, timer, when); timers_check(&timers, "add");
2461         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2462         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2463         when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000;
2464         timer = malloc(sizeof(*timer));
2465         timer_init(timer);
2466         timer_add(&timers, timer, when); timers_check(&timers, "add");
2467         when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
2468         timer = malloc(sizeof(*timer));
2469         timer_init(timer);
2470         timer_add(&timers, timer, when); timers_check(&timers, "add");
2471         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2472         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2473         when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
2474         timer = malloc(sizeof(*timer));
2475         timer_init(timer);
2476         timer_add(&timers, timer, when); timers_check(&timers, "add");
2477         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2478         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2479         when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
2480         timer = malloc(sizeof(*timer));
2481         timer_init(timer);
2482         timer_add(&timers, timer, when); timers_check(&timers, "add");
2483         when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2484         timer = malloc(sizeof(*timer));
2485         timer_init(timer);
2486         timer_add(&timers, timer, when); timers_check(&timers, "add");
2487         when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000;
2488         timer = malloc(sizeof(*timer));
2489         timer_init(timer);
2490         timer_add(&timers, timer, when); timers_check(&timers, "add");
2491         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2492         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2493         when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000;
2494         timer = malloc(sizeof(*timer));
2495         timer_init(timer);
2496         timer_add(&timers, timer, when); timers_check(&timers, "add");
2497         when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
2498         timer = malloc(sizeof(*timer));
2499         timer_init(timer);
2500         timer_add(&timers, timer, when); timers_check(&timers, "add");
2501         when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
2502         timer = malloc(sizeof(*timer));
2503         timer_init(timer);
2504         timer_add(&timers, timer, when); timers_check(&timers, "add");
2505         when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2506         timer = malloc(sizeof(*timer));
2507         timer_init(timer);
2508         timer_add(&timers, timer, when); timers_check(&timers, "add");
2509         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2510         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2511         when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000;
2512         timer = malloc(sizeof(*timer));
2513         timer_init(timer);
2514         timer_add(&timers, timer, when); timers_check(&timers, "add");
2515         when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000;
2516         timer = malloc(sizeof(*timer));
2517         timer_init(timer);
2518         timer_add(&timers, timer, when); timers_check(&timers, "add");
2519         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2520         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2521         when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
2522         timer = malloc(sizeof(*timer));
2523         timer_init(timer);
2524         timer_add(&timers, timer, when); timers_check(&timers, "add");
2525         when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2526         timer = malloc(sizeof(*timer));
2527         timer_init(timer);
2528         timer_add(&timers, timer, when); timers_check(&timers, "add");
2529         when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2530         timer = malloc(sizeof(*timer));
2531         timer_init(timer);
2532         timer_add(&timers, timer, when); timers_check(&timers, "add");
2533         when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2534         timer = malloc(sizeof(*timer));
2535         timer_init(timer);
2536         timer_add(&timers, timer, when); timers_check(&timers, "add");
2537         when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000;
2538         timer = malloc(sizeof(*timer));
2539         timer_init(timer);
2540         timer_add(&timers, timer, when); timers_check(&timers, "add");
2541         when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
2542         timer = malloc(sizeof(*timer));
2543         timer_init(timer);
2544         timer_add(&timers, timer, when); timers_check(&timers, "add");
2545         when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2546         timer = malloc(sizeof(*timer));
2547         timer_init(timer);
2548         timer_add(&timers, timer, when); timers_check(&timers, "add");
2549         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2550         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2551         when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000;
2552         timer = malloc(sizeof(*timer));
2553         timer_init(timer);
2554         timer_add(&timers, timer, when); timers_check(&timers, "add");
2555         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2556         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2557         when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000;
2558         timer = malloc(sizeof(*timer));
2559         timer_init(timer);
2560         timer_add(&timers, timer, when); timers_check(&timers, "add");
2561         when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2562         timer = malloc(sizeof(*timer));
2563         timer_init(timer);
2564         timer_add(&timers, timer, when); timers_check(&timers, "add");
2565         when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000;
2566         timer = malloc(sizeof(*timer));
2567         timer_init(timer);
2568         timer_add(&timers, timer, when); timers_check(&timers, "add");
2569         when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
2570         timer = malloc(sizeof(*timer));
2571         timer_init(timer);
2572         timer_add(&timers, timer, when); timers_check(&timers, "add");
2573         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2574         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2575         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2576         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2577         when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2578         timer = malloc(sizeof(*timer));
2579         timer_init(timer);
2580         timer_add(&timers, timer, when); timers_check(&timers, "add");
2581         when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
2582         timer = malloc(sizeof(*timer));
2583         timer_init(timer);
2584         timer_add(&timers, timer, when); timers_check(&timers, "add");
2585         when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000;
2586         timer = malloc(sizeof(*timer));
2587         timer_init(timer);
2588         timer_add(&timers, timer, when); timers_check(&timers, "add");
2589         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2590         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2591         when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2592         timer = malloc(sizeof(*timer));
2593         timer_init(timer);
2594         timer_add(&timers, timer, when); timers_check(&timers, "add");
2595         when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2596         timer = malloc(sizeof(*timer));
2597         timer_init(timer);
2598         timer_add(&timers, timer, when); timers_check(&timers, "add");
2599         when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2600         timer = malloc(sizeof(*timer));
2601         timer_init(timer);
2602         timer_add(&timers, timer, when); timers_check(&timers, "add");
2603         when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000;
2604         timer = malloc(sizeof(*timer));
2605         timer_init(timer);
2606         timer_add(&timers, timer, when); timers_check(&timers, "add");
2607         when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2608         timer = malloc(sizeof(*timer));
2609         timer_init(timer);
2610         timer_add(&timers, timer, when); timers_check(&timers, "add");
2611         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2612         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2613         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2614         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2615         when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2616         timer = malloc(sizeof(*timer));
2617         timer_init(timer);
2618         timer_add(&timers, timer, when); timers_check(&timers, "add");
2619         when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2620         timer = malloc(sizeof(*timer));
2621         timer_init(timer);
2622         timer_add(&timers, timer, when); timers_check(&timers, "add");
2623         when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2624         timer = malloc(sizeof(*timer));
2625         timer_init(timer);
2626         timer_add(&timers, timer, when); timers_check(&timers, "add");
2627         when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2628         timer = malloc(sizeof(*timer));
2629         timer_init(timer);
2630         timer_add(&timers, timer, when); timers_check(&timers, "add");
2631         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2632         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2633         when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000;
2634         timer = malloc(sizeof(*timer));
2635         timer_init(timer);
2636         timer_add(&timers, timer, when); timers_check(&timers, "add");
2637         when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000;
2638         timer = malloc(sizeof(*timer));
2639         timer_init(timer);
2640         timer_add(&timers, timer, when); timers_check(&timers, "add");
2641         when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
2642         timer = malloc(sizeof(*timer));
2643         timer_init(timer);
2644         timer_add(&timers, timer, when); timers_check(&timers, "add");
2645         when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
2646         timer = malloc(sizeof(*timer));
2647         timer_init(timer);
2648         timer_add(&timers, timer, when); timers_check(&timers, "add");
2649         when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
2650         timer = malloc(sizeof(*timer));
2651         timer_init(timer);
2652         timer_add(&timers, timer, when); timers_check(&timers, "add");
2653         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2654         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2655         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2656         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2657         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2658         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2659         when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000;
2660         timer = malloc(sizeof(*timer));
2661         timer_init(timer);
2662         timer_add(&timers, timer, when); timers_check(&timers, "add");
2663         when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000;
2664         timer = malloc(sizeof(*timer));
2665         timer_init(timer);
2666         timer_add(&timers, timer, when); timers_check(&timers, "add");
2667         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2668         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2669         when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
2670         timer = malloc(sizeof(*timer));
2671         timer_init(timer);
2672         timer_add(&timers, timer, when); timers_check(&timers, "add");
2673         when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2674         timer = malloc(sizeof(*timer));
2675         timer_init(timer);
2676         timer_add(&timers, timer, when); timers_check(&timers, "add");
2677         when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
2678         timer = malloc(sizeof(*timer));
2679         timer_init(timer);
2680         timer_add(&timers, timer, when); timers_check(&timers, "add");
2681         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2682         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2683         when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
2684         timer = malloc(sizeof(*timer));
2685         timer_init(timer);
2686         timer_add(&timers, timer, when); timers_check(&timers, "add");
2687         when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000;
2688         timer = malloc(sizeof(*timer));
2689         timer_init(timer);
2690         timer_add(&timers, timer, when); timers_check(&timers, "add");
2691         when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000;
2692         timer = malloc(sizeof(*timer));
2693         timer_init(timer);
2694         timer_add(&timers, timer, when); timers_check(&timers, "add");
2695         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2696         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2697         when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
2698         timer = malloc(sizeof(*timer));
2699         timer_init(timer);
2700         timer_add(&timers, timer, when); timers_check(&timers, "add");
2701         when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000;
2702         timer = malloc(sizeof(*timer));
2703         timer_init(timer);
2704         timer_add(&timers, timer, when); timers_check(&timers, "add");
2705         when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000;
2706         timer = malloc(sizeof(*timer));
2707         timer_init(timer);
2708         timer_add(&timers, timer, when); timers_check(&timers, "add");
2709         when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000;
2710         timer = malloc(sizeof(*timer));
2711         timer_init(timer);
2712         timer_add(&timers, timer, when); timers_check(&timers, "add");
2713         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2714         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2715         when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2716         timer = malloc(sizeof(*timer));
2717         timer_init(timer);
2718         timer_add(&timers, timer, when); timers_check(&timers, "add");
2719         when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
2720         timer = malloc(sizeof(*timer));
2721         timer_init(timer);
2722         timer_add(&timers, timer, when); timers_check(&timers, "add");
2723         when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2724         timer = malloc(sizeof(*timer));
2725         timer_init(timer);
2726         timer_add(&timers, timer, when); timers_check(&timers, "add");
2727         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2728         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2729         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2730         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2731         when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000;
2732         timer = malloc(sizeof(*timer));
2733         timer_init(timer);
2734         timer_add(&timers, timer, when); timers_check(&timers, "add");
2735         when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000;
2736         timer = malloc(sizeof(*timer));
2737         timer_init(timer);
2738         timer_add(&timers, timer, when); timers_check(&timers, "add");
2739         when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2740         timer = malloc(sizeof(*timer));
2741         timer_init(timer);
2742         timer_add(&timers, timer, when); timers_check(&timers, "add");
2743         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2744         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2745         when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2746         timer = malloc(sizeof(*timer));
2747         timer_init(timer);
2748         timer_add(&timers, timer, when); timers_check(&timers, "add");
2749         when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
2750         timer = malloc(sizeof(*timer));
2751         timer_init(timer);
2752         timer_add(&timers, timer, when); timers_check(&timers, "add");
2753         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2754         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2755         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2756         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2757         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2758         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2759         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2760         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2761         when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000;
2762         timer = malloc(sizeof(*timer));
2763         timer_init(timer);
2764         timer_add(&timers, timer, when); timers_check(&timers, "add");
2765         when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
2766         timer = malloc(sizeof(*timer));
2767         timer_init(timer);
2768         timer_add(&timers, timer, when); timers_check(&timers, "add");
2769         when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
2770         timer = malloc(sizeof(*timer));
2771         timer_init(timer);
2772         timer_add(&timers, timer, when); timers_check(&timers, "add");
2773         when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
2774         timer = malloc(sizeof(*timer));
2775         timer_init(timer);
2776         timer_add(&timers, timer, when); timers_check(&timers, "add");
2777         when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
2778         timer = malloc(sizeof(*timer));
2779         timer_init(timer);
2780         timer_add(&timers, timer, when); timers_check(&timers, "add");
2781         when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2782         timer = malloc(sizeof(*timer));
2783         timer_init(timer);
2784         timer_add(&timers, timer, when); timers_check(&timers, "add");
2785         when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2786         timer = malloc(sizeof(*timer));
2787         timer_init(timer);
2788         timer_add(&timers, timer, when); timers_check(&timers, "add");
2789         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2790         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2791         when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
2792         timer = malloc(sizeof(*timer));
2793         timer_init(timer);
2794         timer_add(&timers, timer, when); timers_check(&timers, "add");
2795         when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
2796         timer = malloc(sizeof(*timer));
2797         timer_init(timer);
2798         timer_add(&timers, timer, when); timers_check(&timers, "add");
2799         when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
2800         timer = malloc(sizeof(*timer));
2801         timer_init(timer);
2802         timer_add(&timers, timer, when); timers_check(&timers, "add");
2803         when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2804         timer = malloc(sizeof(*timer));
2805         timer_init(timer);
2806         timer_add(&timers, timer, when); timers_check(&timers, "add");
2807         when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
2808         timer = malloc(sizeof(*timer));
2809         timer_init(timer);
2810         timer_add(&timers, timer, when); timers_check(&timers, "add");
2811         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2812         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2813         when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
2814         timer = malloc(sizeof(*timer));
2815         timer_init(timer);
2816         timer_add(&timers, timer, when); timers_check(&timers, "add");
2817         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2818         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2819         when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2820         timer = malloc(sizeof(*timer));
2821         timer_init(timer);
2822         timer_add(&timers, timer, when); timers_check(&timers, "add");
2823         when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
2824         timer = malloc(sizeof(*timer));
2825         timer_init(timer);
2826         timer_add(&timers, timer, when); timers_check(&timers, "add");
2827         when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000;
2828         timer = malloc(sizeof(*timer));
2829         timer_init(timer);
2830         timer_add(&timers, timer, when); timers_check(&timers, "add");
2831         when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
2832         timer = malloc(sizeof(*timer));
2833         timer_init(timer);
2834         timer_add(&timers, timer, when); timers_check(&timers, "add");
2835         when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
2836         timer = malloc(sizeof(*timer));
2837         timer_init(timer);
2838         timer_add(&timers, timer, when); timers_check(&timers, "add");
2839         when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000;
2840         timer = malloc(sizeof(*timer));
2841         timer_init(timer);
2842         timer_add(&timers, timer, when); timers_check(&timers, "add");
2843         when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2844         timer = malloc(sizeof(*timer));
2845         timer_init(timer);
2846         timer_add(&timers, timer, when); timers_check(&timers, "add");
2847         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2848         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2849         when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
2850         timer = malloc(sizeof(*timer));
2851         timer_init(timer);
2852         timer_add(&timers, timer, when); timers_check(&timers, "add");
2853         when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
2854         timer = malloc(sizeof(*timer));
2855         timer_init(timer);
2856         timer_add(&timers, timer, when); timers_check(&timers, "add");
2857         when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
2858         timer = malloc(sizeof(*timer));
2859         timer_init(timer);
2860         timer_add(&timers, timer, when); timers_check(&timers, "add");
2861         when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000;
2862         timer = malloc(sizeof(*timer));
2863         timer_init(timer);
2864         timer_add(&timers, timer, when); timers_check(&timers, "add");
2865         when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000;
2866         timer = malloc(sizeof(*timer));
2867         timer_init(timer);
2868         timer_add(&timers, timer, when); timers_check(&timers, "add");
2869         when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000;
2870         timer = malloc(sizeof(*timer));
2871         timer_init(timer);
2872         timer_add(&timers, timer, when); timers_check(&timers, "add");
2873         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2874         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2875         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2876         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2877         when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000;
2878         timer = malloc(sizeof(*timer));
2879         timer_init(timer);
2880         timer_add(&timers, timer, when); timers_check(&timers, "add");
2881         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2882         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2883         when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000;
2884         timer = malloc(sizeof(*timer));
2885         timer_init(timer);
2886         timer_add(&timers, timer, when); timers_check(&timers, "add");
2887         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2888         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2889         when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
2890         timer = malloc(sizeof(*timer));
2891         timer_init(timer);
2892         timer_add(&timers, timer, when); timers_check(&timers, "add");
2893         when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
2894         timer = malloc(sizeof(*timer));
2895         timer_init(timer);
2896         timer_add(&timers, timer, when); timers_check(&timers, "add");
2897         when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
2898         timer = malloc(sizeof(*timer));
2899         timer_init(timer);
2900         timer_add(&timers, timer, when); timers_check(&timers, "add");
2901         when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000;
2902         timer = malloc(sizeof(*timer));
2903         timer_init(timer);
2904         timer_add(&timers, timer, when); timers_check(&timers, "add");
2905         when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
2906         timer = malloc(sizeof(*timer));
2907         timer_init(timer);
2908         timer_add(&timers, timer, when); timers_check(&timers, "add");
2909         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2910         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2911         when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000;
2912         timer = malloc(sizeof(*timer));
2913         timer_init(timer);
2914         timer_add(&timers, timer, when); timers_check(&timers, "add");
2915         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2916         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2917         when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000;
2918         timer = malloc(sizeof(*timer));
2919         timer_init(timer);
2920         timer_add(&timers, timer, when); timers_check(&timers, "add");
2921         when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
2922         timer = malloc(sizeof(*timer));
2923         timer_init(timer);
2924         timer_add(&timers, timer, when); timers_check(&timers, "add");
2925         when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000;
2926         timer = malloc(sizeof(*timer));
2927         timer_init(timer);
2928         timer_add(&timers, timer, when); timers_check(&timers, "add");
2929         when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
2930         timer = malloc(sizeof(*timer));
2931         timer_init(timer);
2932         timer_add(&timers, timer, when); timers_check(&timers, "add");
2933         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2934         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2935         when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
2936         timer = malloc(sizeof(*timer));
2937         timer_init(timer);
2938         timer_add(&timers, timer, when); timers_check(&timers, "add");
2939         when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
2940         timer = malloc(sizeof(*timer));
2941         timer_init(timer);
2942         timer_add(&timers, timer, when); timers_check(&timers, "add");
2943         when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
2944         timer = malloc(sizeof(*timer));
2945         timer_init(timer);
2946         timer_add(&timers, timer, when); timers_check(&timers, "add");
2947         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2948         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2949         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2950         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2951         when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
2952         timer = malloc(sizeof(*timer));
2953         timer_init(timer);
2954         timer_add(&timers, timer, when); timers_check(&timers, "add");
2955         when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000;
2956         timer = malloc(sizeof(*timer));
2957         timer_init(timer);
2958         timer_add(&timers, timer, when); timers_check(&timers, "add");
2959         when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000;
2960         timer = malloc(sizeof(*timer));
2961         timer_init(timer);
2962         timer_add(&timers, timer, when); timers_check(&timers, "add");
2963         when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000;
2964         timer = malloc(sizeof(*timer));
2965         timer_init(timer);
2966         timer_add(&timers, timer, when); timers_check(&timers, "add");
2967         when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
2968         timer = malloc(sizeof(*timer));
2969         timer_init(timer);
2970         timer_add(&timers, timer, when); timers_check(&timers, "add");
2971         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2972         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2973         when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000;
2974         timer = malloc(sizeof(*timer));
2975         timer_init(timer);
2976         timer_add(&timers, timer, when); timers_check(&timers, "add");
2977         when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000;
2978         timer = malloc(sizeof(*timer));
2979         timer_init(timer);
2980         timer_add(&timers, timer, when); timers_check(&timers, "add");
2981         when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000;
2982         timer = malloc(sizeof(*timer));
2983         timer_init(timer);
2984         timer_add(&timers, timer, when); timers_check(&timers, "add");
2985         when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000;
2986         timer = malloc(sizeof(*timer));
2987         timer_init(timer);
2988         timer_add(&timers, timer, when); timers_check(&timers, "add");
2989         when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2990         timer = malloc(sizeof(*timer));
2991         timer_init(timer);
2992         timer_add(&timers, timer, when); timers_check(&timers, "add");
2993         when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
2994         timer = malloc(sizeof(*timer));
2995         timer_init(timer);
2996         timer_add(&timers, timer, when); timers_check(&timers, "add");
2997         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
2998         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
2999         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3000         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3001         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3002         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3003         when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3004         timer = malloc(sizeof(*timer));
3005         timer_init(timer);
3006         timer_add(&timers, timer, when); timers_check(&timers, "add");
3007         when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000;
3008         timer = malloc(sizeof(*timer));
3009         timer_init(timer);
3010         timer_add(&timers, timer, when); timers_check(&timers, "add");
3011         when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000;
3012         timer = malloc(sizeof(*timer));
3013         timer_init(timer);
3014         timer_add(&timers, timer, when); timers_check(&timers, "add");
3015         when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3016         timer = malloc(sizeof(*timer));
3017         timer_init(timer);
3018         timer_add(&timers, timer, when); timers_check(&timers, "add");
3019         when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3020         timer = malloc(sizeof(*timer));
3021         timer_init(timer);
3022         timer_add(&timers, timer, when); timers_check(&timers, "add");
3023         when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000;
3024         timer = malloc(sizeof(*timer));
3025         timer_init(timer);
3026         timer_add(&timers, timer, when); timers_check(&timers, "add");
3027         when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000;
3028         timer = malloc(sizeof(*timer));
3029         timer_init(timer);
3030         timer_add(&timers, timer, when); timers_check(&timers, "add");
3031         when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000;
3032         timer = malloc(sizeof(*timer));
3033         timer_init(timer);
3034         timer_add(&timers, timer, when); timers_check(&timers, "add");
3035         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3036         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3037         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3038         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3039         when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3040         timer = malloc(sizeof(*timer));
3041         timer_init(timer);
3042         timer_add(&timers, timer, when); timers_check(&timers, "add");
3043         when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3044         timer = malloc(sizeof(*timer));
3045         timer_init(timer);
3046         timer_add(&timers, timer, when); timers_check(&timers, "add");
3047         when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3048         timer = malloc(sizeof(*timer));
3049         timer_init(timer);
3050         timer_add(&timers, timer, when); timers_check(&timers, "add");
3051         when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000;
3052         timer = malloc(sizeof(*timer));
3053         timer_init(timer);
3054         timer_add(&timers, timer, when); timers_check(&timers, "add");
3055         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3056         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3057         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3058         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3059         when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3060         timer = malloc(sizeof(*timer));
3061         timer_init(timer);
3062         timer_add(&timers, timer, when); timers_check(&timers, "add");
3063         when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000;
3064         timer = malloc(sizeof(*timer));
3065         timer_init(timer);
3066         timer_add(&timers, timer, when); timers_check(&timers, "add");
3067         when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3068         timer = malloc(sizeof(*timer));
3069         timer_init(timer);
3070         timer_add(&timers, timer, when); timers_check(&timers, "add");
3071         when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000;
3072         timer = malloc(sizeof(*timer));
3073         timer_init(timer);
3074         timer_add(&timers, timer, when); timers_check(&timers, "add");
3075         when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3076         timer = malloc(sizeof(*timer));
3077         timer_init(timer);
3078         timer_add(&timers, timer, when); timers_check(&timers, "add");
3079         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3080         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3081         when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000;
3082         timer = malloc(sizeof(*timer));
3083         timer_init(timer);
3084         timer_add(&timers, timer, when); timers_check(&timers, "add");
3085         when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3086         timer = malloc(sizeof(*timer));
3087         timer_init(timer);
3088         timer_add(&timers, timer, when); timers_check(&timers, "add");
3089         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3090         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3091         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3092         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3093         when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000;
3094         timer = malloc(sizeof(*timer));
3095         timer_init(timer);
3096         timer_add(&timers, timer, when); timers_check(&timers, "add");
3097         when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000;
3098         timer = malloc(sizeof(*timer));
3099         timer_init(timer);
3100         timer_add(&timers, timer, when); timers_check(&timers, "add");
3101         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3102         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3103         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3104         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3105         when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000;
3106         timer = malloc(sizeof(*timer));
3107         timer_init(timer);
3108         timer_add(&timers, timer, when); timers_check(&timers, "add");
3109         when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3110         timer = malloc(sizeof(*timer));
3111         timer_init(timer);
3112         timer_add(&timers, timer, when); timers_check(&timers, "add");
3113         when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000;
3114         timer = malloc(sizeof(*timer));
3115         timer_init(timer);
3116         timer_add(&timers, timer, when); timers_check(&timers, "add");
3117         when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3118         timer = malloc(sizeof(*timer));
3119         timer_init(timer);
3120         timer_add(&timers, timer, when); timers_check(&timers, "add");
3121         when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000;
3122         timer = malloc(sizeof(*timer));
3123         timer_init(timer);
3124         timer_add(&timers, timer, when); timers_check(&timers, "add");
3125         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3126         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3127         when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3128         timer = malloc(sizeof(*timer));
3129         timer_init(timer);
3130         timer_add(&timers, timer, when); timers_check(&timers, "add");
3131         when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000;
3132         timer = malloc(sizeof(*timer));
3133         timer_init(timer);
3134         timer_add(&timers, timer, when); timers_check(&timers, "add");
3135         when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000;
3136         timer = malloc(sizeof(*timer));
3137         timer_init(timer);
3138         timer_add(&timers, timer, when); timers_check(&timers, "add");
3139         when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3140         timer = malloc(sizeof(*timer));
3141         timer_init(timer);
3142         timer_add(&timers, timer, when); timers_check(&timers, "add");
3143         when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000;
3144         timer = malloc(sizeof(*timer));
3145         timer_init(timer);
3146         timer_add(&timers, timer, when); timers_check(&timers, "add");
3147         when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000;
3148         timer = malloc(sizeof(*timer));
3149         timer_init(timer);
3150         timer_add(&timers, timer, when); timers_check(&timers, "add");
3151         when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000;
3152         timer = malloc(sizeof(*timer));
3153         timer_init(timer);
3154         timer_add(&timers, timer, when); timers_check(&timers, "add");
3155         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3156         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3157         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3158         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3159         when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3160         timer = malloc(sizeof(*timer));
3161         timer_init(timer);
3162         timer_add(&timers, timer, when); timers_check(&timers, "add");
3163         when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000;
3164         timer = malloc(sizeof(*timer));
3165         timer_init(timer);
3166         timer_add(&timers, timer, when); timers_check(&timers, "add");
3167         when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3168         timer = malloc(sizeof(*timer));
3169         timer_init(timer);
3170         timer_add(&timers, timer, when); timers_check(&timers, "add");
3171         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3172         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3173         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3174         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3175         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3176         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3177         when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000;
3178         timer = malloc(sizeof(*timer));
3179         timer_init(timer);
3180         timer_add(&timers, timer, when); timers_check(&timers, "add");
3181         when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3182         timer = malloc(sizeof(*timer));
3183         timer_init(timer);
3184         timer_add(&timers, timer, when); timers_check(&timers, "add");
3185         when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000;
3186         timer = malloc(sizeof(*timer));
3187         timer_init(timer);
3188         timer_add(&timers, timer, when); timers_check(&timers, "add");
3189         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3190         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3191         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3192         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3193         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3194         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3195         when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000;
3196         timer = malloc(sizeof(*timer));
3197         timer_init(timer);
3198         timer_add(&timers, timer, when); timers_check(&timers, "add");
3199         when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000;
3200         timer = malloc(sizeof(*timer));
3201         timer_init(timer);
3202         timer_add(&timers, timer, when); timers_check(&timers, "add");
3203         when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3204         timer = malloc(sizeof(*timer));
3205         timer_init(timer);
3206         timer_add(&timers, timer, when); timers_check(&timers, "add");
3207         when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3208         timer = malloc(sizeof(*timer));
3209         timer_init(timer);
3210         timer_add(&timers, timer, when); timers_check(&timers, "add");
3211         when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000;
3212         timer = malloc(sizeof(*timer));
3213         timer_init(timer);
3214         timer_add(&timers, timer, when); timers_check(&timers, "add");
3215         when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3216         timer = malloc(sizeof(*timer));
3217         timer_init(timer);
3218         timer_add(&timers, timer, when); timers_check(&timers, "add");
3219         when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3220         timer = malloc(sizeof(*timer));
3221         timer_init(timer);
3222         timer_add(&timers, timer, when); timers_check(&timers, "add");
3223         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3224         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3225         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3226         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3227         when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000;
3228         timer = malloc(sizeof(*timer));
3229         timer_init(timer);
3230         timer_add(&timers, timer, when); timers_check(&timers, "add");
3231         when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3232         timer = malloc(sizeof(*timer));
3233         timer_init(timer);
3234         timer_add(&timers, timer, when); timers_check(&timers, "add");
3235         when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000;
3236         timer = malloc(sizeof(*timer));
3237         timer_init(timer);
3238         timer_add(&timers, timer, when); timers_check(&timers, "add");
3239         when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000;
3240         timer = malloc(sizeof(*timer));
3241         timer_init(timer);
3242         timer_add(&timers, timer, when); timers_check(&timers, "add");
3243         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3244         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3245         when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000;
3246         timer = malloc(sizeof(*timer));
3247         timer_init(timer);
3248         timer_add(&timers, timer, when); timers_check(&timers, "add");
3249         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3250         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3251         when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000;
3252         timer = malloc(sizeof(*timer));
3253         timer_init(timer);
3254         timer_add(&timers, timer, when); timers_check(&timers, "add");
3255         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3256         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3257         when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000;
3258         timer = malloc(sizeof(*timer));
3259         timer_init(timer);
3260         timer_add(&timers, timer, when); timers_check(&timers, "add");
3261         when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000;
3262         timer = malloc(sizeof(*timer));
3263         timer_init(timer);
3264         timer_add(&timers, timer, when); timers_check(&timers, "add");
3265         when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000;
3266         timer = malloc(sizeof(*timer));
3267         timer_init(timer);
3268         timer_add(&timers, timer, when); timers_check(&timers, "add");
3269         when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3270         timer = malloc(sizeof(*timer));
3271         timer_init(timer);
3272         timer_add(&timers, timer, when); timers_check(&timers, "add");
3273         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3274         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3275         when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000;
3276         timer = malloc(sizeof(*timer));
3277         timer_init(timer);
3278         timer_add(&timers, timer, when); timers_check(&timers, "add");
3279         when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000;
3280         timer = malloc(sizeof(*timer));
3281         timer_init(timer);
3282         timer_add(&timers, timer, when); timers_check(&timers, "add");
3283         when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3284         timer = malloc(sizeof(*timer));
3285         timer_init(timer);
3286         timer_add(&timers, timer, when); timers_check(&timers, "add");
3287         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3288         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3289         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3290         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3291         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3292         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3293         when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3294         timer = malloc(sizeof(*timer));
3295         timer_init(timer);
3296         timer_add(&timers, timer, when); timers_check(&timers, "add");
3297         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3298         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3299         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3300         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3301         when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000;
3302         timer = malloc(sizeof(*timer));
3303         timer_init(timer);
3304         timer_add(&timers, timer, when); timers_check(&timers, "add");
3305         when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3306         timer = malloc(sizeof(*timer));
3307         timer_init(timer);
3308         timer_add(&timers, timer, when); timers_check(&timers, "add");
3309         when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000;
3310         timer = malloc(sizeof(*timer));
3311         timer_init(timer);
3312         timer_add(&timers, timer, when); timers_check(&timers, "add");
3313         when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000;
3314         timer = malloc(sizeof(*timer));
3315         timer_init(timer);
3316         timer_add(&timers, timer, when); timers_check(&timers, "add");
3317         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3318         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3319         when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000;
3320         timer = malloc(sizeof(*timer));
3321         timer_init(timer);
3322         timer_add(&timers, timer, when); timers_check(&timers, "add");
3323         when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000;
3324         timer = malloc(sizeof(*timer));
3325         timer_init(timer);
3326         timer_add(&timers, timer, when); timers_check(&timers, "add");
3327         when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000;
3328         timer = malloc(sizeof(*timer));
3329         timer_init(timer);
3330         timer_add(&timers, timer, when); timers_check(&timers, "add");
3331         when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000;
3332         timer = malloc(sizeof(*timer));
3333         timer_init(timer);
3334         timer_add(&timers, timer, when); timers_check(&timers, "add");
3335         when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3336         timer = malloc(sizeof(*timer));
3337         timer_init(timer);
3338         timer_add(&timers, timer, when); timers_check(&timers, "add");
3339         when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000;
3340         timer = malloc(sizeof(*timer));
3341         timer_init(timer);
3342         timer_add(&timers, timer, when); timers_check(&timers, "add");
3343         when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000;
3344         timer = malloc(sizeof(*timer));
3345         timer_init(timer);
3346         timer_add(&timers, timer, when); timers_check(&timers, "add");
3347         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3348         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3349         when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000;
3350         timer = malloc(sizeof(*timer));
3351         timer_init(timer);
3352         timer_add(&timers, timer, when); timers_check(&timers, "add");
3353         when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000;
3354         timer = malloc(sizeof(*timer));
3355         timer_init(timer);
3356         timer_add(&timers, timer, when); timers_check(&timers, "add");
3357         when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3358         timer = malloc(sizeof(*timer));
3359         timer_init(timer);
3360         timer_add(&timers, timer, when); timers_check(&timers, "add");
3361         when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3362         timer = malloc(sizeof(*timer));
3363         timer_init(timer);
3364         timer_add(&timers, timer, when); timers_check(&timers, "add");
3365         when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3366         timer = malloc(sizeof(*timer));
3367         timer_init(timer);
3368         timer_add(&timers, timer, when); timers_check(&timers, "add");
3369         when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000;
3370         timer = malloc(sizeof(*timer));
3371         timer_init(timer);
3372         timer_add(&timers, timer, when); timers_check(&timers, "add");
3373         when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000;
3374         timer = malloc(sizeof(*timer));
3375         timer_init(timer);
3376         timer_add(&timers, timer, when); timers_check(&timers, "add");
3377         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3378         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3379         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3380         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3381         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3382         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3383         when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000;
3384         timer = malloc(sizeof(*timer));
3385         timer_init(timer);
3386         timer_add(&timers, timer, when); timers_check(&timers, "add");
3387         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3388         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3389         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3390         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3391         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3392         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3393         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3394         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3395         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3396         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3397         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3398         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3399         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3400         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3401         when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000;
3402         timer = malloc(sizeof(*timer));
3403         timer_init(timer);
3404         timer_add(&timers, timer, when); timers_check(&timers, "add");
3405         when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000;
3406         timer = malloc(sizeof(*timer));
3407         timer_init(timer);
3408         timer_add(&timers, timer, when); timers_check(&timers, "add");
3409         when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000;
3410         timer = malloc(sizeof(*timer));
3411         timer_init(timer);
3412         timer_add(&timers, timer, when); timers_check(&timers, "add");
3413         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3414         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3415         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3416         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3417         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3418         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3419         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3420         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3421         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3422         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3423         when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3424         timer = malloc(sizeof(*timer));
3425         timer_init(timer);
3426         timer_add(&timers, timer, when); timers_check(&timers, "add");
3427         when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000;
3428         timer = malloc(sizeof(*timer));
3429         timer_init(timer);
3430         timer_add(&timers, timer, when); timers_check(&timers, "add");
3431         when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3432         timer = malloc(sizeof(*timer));
3433         timer_init(timer);
3434         timer_add(&timers, timer, when); timers_check(&timers, "add");
3435         when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000;
3436         timer = malloc(sizeof(*timer));
3437         timer_init(timer);
3438         timer_add(&timers, timer, when); timers_check(&timers, "add");
3439         when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000;
3440         timer = malloc(sizeof(*timer));
3441         timer_init(timer);
3442         timer_add(&timers, timer, when); timers_check(&timers, "add");
3443         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3444         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3445         when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000;
3446         timer = malloc(sizeof(*timer));
3447         timer_init(timer);
3448         timer_add(&timers, timer, when); timers_check(&timers, "add");
3449         when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000;
3450         timer = malloc(sizeof(*timer));
3451         timer_init(timer);
3452         timer_add(&timers, timer, when); timers_check(&timers, "add");
3453         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3454         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3455         when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000;
3456         timer = malloc(sizeof(*timer));
3457         timer_init(timer);
3458         timer_add(&timers, timer, when); timers_check(&timers, "add");
3459         when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000;
3460         timer = malloc(sizeof(*timer));
3461         timer_init(timer);
3462         timer_add(&timers, timer, when); timers_check(&timers, "add");
3463         when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000;
3464         timer = malloc(sizeof(*timer));
3465         timer_init(timer);
3466         timer_add(&timers, timer, when); timers_check(&timers, "add");
3467         when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000;
3468         timer = malloc(sizeof(*timer));
3469         timer_init(timer);
3470         timer_add(&timers, timer, when); timers_check(&timers, "add");
3471         when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000;
3472         timer = malloc(sizeof(*timer));
3473         timer_init(timer);
3474         timer_add(&timers, timer, when); timers_check(&timers, "add");
3475         when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000;
3476         timer = malloc(sizeof(*timer));
3477         timer_init(timer);
3478         timer_add(&timers, timer, when); timers_check(&timers, "add");
3479         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3480         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3481         when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3482         timer = malloc(sizeof(*timer));
3483         timer_init(timer);
3484         timer_add(&timers, timer, when); timers_check(&timers, "add");
3485         when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000;
3486         timer = malloc(sizeof(*timer));
3487         timer_init(timer);
3488         timer_add(&timers, timer, when); timers_check(&timers, "add");
3489         when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000;
3490         timer = malloc(sizeof(*timer));
3491         timer_init(timer);
3492         timer_add(&timers, timer, when); timers_check(&timers, "add");
3493         when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000;
3494         timer = malloc(sizeof(*timer));
3495         timer_init(timer);
3496         timer_add(&timers, timer, when); timers_check(&timers, "add");
3497         when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000;
3498         timer = malloc(sizeof(*timer));
3499         timer_init(timer);
3500         timer_add(&timers, timer, when); timers_check(&timers, "add");
3501         when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3502         timer = malloc(sizeof(*timer));
3503         timer_init(timer);
3504         timer_add(&timers, timer, when); timers_check(&timers, "add");
3505         when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000;
3506         timer = malloc(sizeof(*timer));
3507         timer_init(timer);
3508         timer_add(&timers, timer, when); timers_check(&timers, "add");
3509         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3510         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3511         when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000;
3512         timer = malloc(sizeof(*timer));
3513         timer_init(timer);
3514         timer_add(&timers, timer, when); timers_check(&timers, "add");
3515         when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000;
3516         timer = malloc(sizeof(*timer));
3517         timer_init(timer);
3518         timer_add(&timers, timer, when); timers_check(&timers, "add");
3519         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3520         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3521         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3522         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3523         when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000;
3524         timer = malloc(sizeof(*timer));
3525         timer_init(timer);
3526         timer_add(&timers, timer, when); timers_check(&timers, "add");
3527         when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000;
3528         timer = malloc(sizeof(*timer));
3529         timer_init(timer);
3530         timer_add(&timers, timer, when); timers_check(&timers, "add");
3531         when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000;
3532         timer = malloc(sizeof(*timer));
3533         timer_init(timer);
3534         timer_add(&timers, timer, when); timers_check(&timers, "add");
3535         when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000;
3536         timer = malloc(sizeof(*timer));
3537         timer_init(timer);
3538         timer_add(&timers, timer, when); timers_check(&timers, "add");
3539         when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000;
3540         timer = malloc(sizeof(*timer));
3541         timer_init(timer);
3542         timer_add(&timers, timer, when); timers_check(&timers, "add");
3543         when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000;
3544         timer = malloc(sizeof(*timer));
3545         timer_init(timer);
3546         timer_add(&timers, timer, when); timers_check(&timers, "add");
3547         when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3548         timer = malloc(sizeof(*timer));
3549         timer_init(timer);
3550         timer_add(&timers, timer, when); timers_check(&timers, "add");
3551         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3552         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3553         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3554         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3555         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3556         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3557         when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000;
3558         timer = malloc(sizeof(*timer));
3559         timer_init(timer);
3560         timer_add(&timers, timer, when); timers_check(&timers, "add");
3561         when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000;
3562         timer = malloc(sizeof(*timer));
3563         timer_init(timer);
3564         timer_add(&timers, timer, when); timers_check(&timers, "add");
3565         when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000;
3566         timer = malloc(sizeof(*timer));
3567         timer_init(timer);
3568         timer_add(&timers, timer, when); timers_check(&timers, "add");
3569         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3570         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3571         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3572         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3573         when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000;
3574         timer = malloc(sizeof(*timer));
3575         timer_init(timer);
3576         timer_add(&timers, timer, when); timers_check(&timers, "add");
3577         when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3578         timer = malloc(sizeof(*timer));
3579         timer_init(timer);
3580         timer_add(&timers, timer, when); timers_check(&timers, "add");
3581         when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3582         timer = malloc(sizeof(*timer));
3583         timer_init(timer);
3584         timer_add(&timers, timer, when); timers_check(&timers, "add");
3585         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3586         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3587         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3588         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3589         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3590         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3591         when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3592         timer = malloc(sizeof(*timer));
3593         timer_init(timer);
3594         timer_add(&timers, timer, when); timers_check(&timers, "add");
3595         when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000;
3596         timer = malloc(sizeof(*timer));
3597         timer_init(timer);
3598         timer_add(&timers, timer, when); timers_check(&timers, "add");
3599         when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000;
3600         timer = malloc(sizeof(*timer));
3601         timer_init(timer);
3602         timer_add(&timers, timer, when); timers_check(&timers, "add");
3603         when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000;
3604         timer = malloc(sizeof(*timer));
3605         timer_init(timer);
3606         timer_add(&timers, timer, when); timers_check(&timers, "add");
3607         when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000;
3608         timer = malloc(sizeof(*timer));
3609         timer_init(timer);
3610         timer_add(&timers, timer, when); timers_check(&timers, "add");
3611         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3612         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3613         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3614         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3615         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3616         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3617         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3618         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3619         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3620         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3621         when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000;
3622         timer = malloc(sizeof(*timer));
3623         timer_init(timer);
3624         timer_add(&timers, timer, when); timers_check(&timers, "add");
3625         when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000;
3626         timer = malloc(sizeof(*timer));
3627         timer_init(timer);
3628         timer_add(&timers, timer, when); timers_check(&timers, "add");
3629         when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000;
3630         timer = malloc(sizeof(*timer));
3631         timer_init(timer);
3632         timer_add(&timers, timer, when); timers_check(&timers, "add");
3633         when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000;
3634         timer = malloc(sizeof(*timer));
3635         timer_init(timer);
3636         timer_add(&timers, timer, when); timers_check(&timers, "add");
3637         when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000;
3638         timer = malloc(sizeof(*timer));
3639         timer_init(timer);
3640         timer_add(&timers, timer, when); timers_check(&timers, "add");
3641         when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000;
3642         timer = malloc(sizeof(*timer));
3643         timer_init(timer);
3644         timer_add(&timers, timer, when); timers_check(&timers, "add");
3645         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3646         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3647         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3648         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3649         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3650         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3651         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3652         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3653         when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000;
3654         timer = malloc(sizeof(*timer));
3655         timer_init(timer);
3656         timer_add(&timers, timer, when); timers_check(&timers, "add");
3657         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3658         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3659         when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000;
3660         timer = malloc(sizeof(*timer));
3661         timer_init(timer);
3662         timer_add(&timers, timer, when); timers_check(&timers, "add");
3663         when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000;
3664         timer = malloc(sizeof(*timer));
3665         timer_init(timer);
3666         timer_add(&timers, timer, when); timers_check(&timers, "add");
3667         when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000;
3668         timer = malloc(sizeof(*timer));
3669         timer_init(timer);
3670         timer_add(&timers, timer, when); timers_check(&timers, "add");
3671         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3672         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3673         when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000;
3674         timer = malloc(sizeof(*timer));
3675         timer_init(timer);
3676         timer_add(&timers, timer, when); timers_check(&timers, "add");
3677         when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000;
3678         timer = malloc(sizeof(*timer));
3679         timer_init(timer);
3680         timer_add(&timers, timer, when); timers_check(&timers, "add");
3681         when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000;
3682         timer = malloc(sizeof(*timer));
3683         timer_init(timer);
3684         timer_add(&timers, timer, when); timers_check(&timers, "add");
3685         when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000;
3686         timer = malloc(sizeof(*timer));
3687         timer_init(timer);
3688         timer_add(&timers, timer, when); timers_check(&timers, "add");
3689         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3690         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3691         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3692         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3693         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3694         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3695         when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000;
3696         timer = malloc(sizeof(*timer));
3697         timer_init(timer);
3698         timer_add(&timers, timer, when); timers_check(&timers, "add");
3699         when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000;
3700         timer = malloc(sizeof(*timer));
3701         timer_init(timer);
3702         timer_add(&timers, timer, when); timers_check(&timers, "add");
3703         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3704         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3705         when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000;
3706         timer = malloc(sizeof(*timer));
3707         timer_init(timer);
3708         timer_add(&timers, timer, when); timers_check(&timers, "add");
3709         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3710         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3711         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3712         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3713         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3714         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3715         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3716         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3717         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3718         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3719         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3720         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3721         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3722         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3723         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3724         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3725         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3726         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3727         when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000;
3728         timer = malloc(sizeof(*timer));
3729         timer_init(timer);
3730         timer_add(&timers, timer, when); timers_check(&timers, "add");
3731         when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000;
3732         timer = malloc(sizeof(*timer));
3733         timer_init(timer);
3734         timer_add(&timers, timer, when); timers_check(&timers, "add");
3735         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3736         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3737         when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000;
3738         timer = malloc(sizeof(*timer));
3739         timer_init(timer);
3740         timer_add(&timers, timer, when); timers_check(&timers, "add");
3741         when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000;
3742         timer = malloc(sizeof(*timer));
3743         timer_init(timer);
3744         timer_add(&timers, timer, when); timers_check(&timers, "add");
3745         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3746         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3747         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3748         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3749         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3750         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3751         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3752         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3753         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3754         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3755         when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000;
3756         timer = malloc(sizeof(*timer));
3757         timer_init(timer);
3758         timer_add(&timers, timer, when); timers_check(&timers, "add");
3759         when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000;
3760         timer = malloc(sizeof(*timer));
3761         timer_init(timer);
3762         timer_add(&timers, timer, when); timers_check(&timers, "add");
3763         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3764         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3765         timer_earliest(&timers, &when); timers_check(&timers, "earliest");
3766         free(timers_expire(&timers, when)); timers_check(&timers, "expire");
3767         when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000;
3768         timer = malloc(sizeof(*timer));
3769         timer_init(timer);
3770         timer_add(&timers, timer, when); timers_check(&timers, "add");
3771         when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000;
3772         timer = malloc(sizeof(*timer));
3773         timer_init(timer);
3774         timer_add(&timers, timer, when); timers_check(&timers, "add");
3775         when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000;
3776         timer = malloc(sizeof(*timer));
3777         timer_init(timer);
3778         timer_add(&timers, timer, when); timers_check(&timers, "add");
3779         when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000;
3780         timer = malloc(sizeof(*timer));
3781         timer_init(timer);
3782         timer_add(&timers, timer, when); timers_check(&timers, "add");