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

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