struct ev_loop;

enum {

    EV_UNDEF = (int)0xFFFFFFFF,

    EV_NONE = 0x00,

    EV_READ = 0x01,

    EV_WRITE = 0x02,

    EV__IOFDSET = 0x80,

    EV_IO = EV_READ,

    EV_TIMER = 0x00000100,

    EV_TIMEOUT = EV_TIMER,

    EV_PERIODIC = 0x00000200,

    EV_SIGNAL = 0x00000400,

    EV_CHILD = 0x00000800,

    EV_STAT = 0x00001000,

    EV_IDLE = 0x00002000,

    EV_PREPARE = 0x00004000,

    EV_CHECK = 0x00008000,

    EV_EMBED = 0x00010000,

    EV_FORK = 0x00020000,

    EV_CLEANUP = 0x00040000,

    EV_ASYNC = 0x00080000,

    EV_CUSTOM = 0x01000000,

    EV_ERROR = (int)0x80000000

};

typedef struct ev_watcher

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher *w, int revents);

} ev_watcher;

typedef struct ev_watcher_list

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher_list *w, int revents);

    struct ev_watcher_list *next;

} ev_watcher_list;

typedef struct ev_watcher_time

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_watcher_time *w, int revents);

    ev_tstamp at;

} ev_watcher_time;

typedef struct ev_io

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_io *w, int revents);

    struct ev_watcher_list *next;

    int fd;

    int events;

} ev_io;

typedef struct ev_timer

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_timer *w, int revents);

    ev_tstamp at;

    ev_tstamp repeat;

} ev_timer;

typedef struct ev_periodic

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_periodic *w, int revents); ev_tstamp at;

    ev_tstamp offset;

    ev_tstamp interval;

    ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) ;

} ev_periodic;

typedef struct ev_signal

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_signal *w, int revents);

    struct ev_watcher_list *next;

    int signum;

} ev_signal;

typedef struct ev_child

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_child *w, int revents);

    struct ev_watcher_list *next;

    int flags;

    int pid;

    int rpid;

    int rstatus;

} ev_child;

typedef struct stat ev_statdata;

typedef struct ev_stat

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_stat *w, int revents);

    struct ev_watcher_list *next;

    ev_timer timer;

    ev_tstamp interval;

    const char *path;

    ev_statdata prev;

    ev_statdata attr;

    int wd;

} ev_stat;

typedef struct ev_idle

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_idle *w, int revents);

} ev_idle;

typedef struct ev_prepare

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_prepare *w, int revents);

} ev_prepare;

typedef struct ev_check

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_check *w, int revents);

} ev_check;

typedef struct ev_fork

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_fork *w, int revents);

} ev_fork;

typedef struct ev_cleanup

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_cleanup *w, int revents);

} ev_cleanup;

typedef struct ev_embed

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_embed *w, int revents);

    struct ev_loop *other;

    ev_io io;

    ev_prepare prepare;

    ev_check check;

    ev_timer timer;

    ev_periodic periodic;

    ev_idle idle;

    ev_fork fork;

    ev_cleanup cleanup;

} ev_embed;

typedef struct ev_async

{

    int active; int pending; int priority; void *data; void (*cb)(struct ev_loop *loop, struct ev_async *w, int revents);

    sig_atomic_t volatile sent;

} ev_async;

union ev_any_watcher

{

    struct ev_watcher w;

    struct ev_watcher_list wl;

    struct ev_io io;

    struct ev_timer timer;

    struct ev_periodic periodic;

    struct ev_signal signal;

    struct ev_child child;

    struct ev_stat stat;

    struct ev_idle idle;

    struct ev_prepare prepare;

    struct ev_check check;

    struct ev_fork fork;

    struct ev_cleanup cleanup;

    struct ev_embed embed;

    struct ev_async async;

};

enum {

    EVFLAG_AUTO = 0x00000000U,

    EVFLAG_NOENV = 0x01000000U,

    EVFLAG_FORKCHECK = 0x02000000U,

    EVFLAG_NOINOTIFY = 0x00100000U,

    EVFLAG_NOSIGFD = ,

    EVFLAG_SIGNALFD = 0x00200000U,

    EVFLAG_NOSIGMASK = 0x00400000U

};

enum {

    EVBACKEND_SELECT = 0x00000001U,

    EVBACKEND_POLL = 0x00000002U,

    EVBACKEND_EPOLL = 0x00000004U,

    EVBACKEND_KQUEUE = 0x00000008U,

    EVBACKEND_DEVPOLL = 0x00000010U,

    EVBACKEND_PORT = 0x00000020U,

    EVBACKEND_ALL = 0x0000003FU,

    EVBACKEND_MASK = 0x0000FFFFU

};

extern int ev_version_major (void) ;

extern int ev_version_minor (void) ;

extern unsigned int ev_supported_backends (void) ;

extern unsigned int ev_recommended_backends (void) ;

extern unsigned int ev_embeddable_backends (void) ;

extern ev_tstamp ev_time (void) ;

extern void ev_sleep (ev_tstamp delay) ;

extern void ev_set_allocator (void *(*cb)(void *ptr, long size) ) ;

extern void ev_set_syserr_cb (void (*cb)(const char *msg) ) ;

extern struct ev_loop *ev_default_loop (unsigned int flags ) ;

static inline struct ev_loop *

ev_default_loop_uc_ (void)

{

    extern struct ev_loop *ev_default_loop_ptr;

    return ev_default_loop_ptr;

}

static inline int

ev_is_default_loop (struct ev_loop *loop)

{

    return loop == ev_default_loop_uc_ ();

}

extern struct ev_loop *ev_loop_new (unsigned int flags ) ;

static inline void

idle_reify (struct ev_loop *loop)

{

    if (__builtin_expect ((!!(((loop)->idleall))),()))

    {

        int pri;

        for (pri = ((((0x7f) & ) ? + : ) - (((0x7f) & ) ? - : ) + ); pri--; )

        {

            if (((loop)->pendingcnt) [pri])

                break;

            if (((loop)->idlecnt) [pri])

            {

                queue_events (loop, (W *)((loop)->idles) [pri], ((loop)->idlecnt) [pri], EV_IDLE);

                break;

            }

        }

    }

}

static inline void

timers_reify (struct ev_loop *loop)

{

    do { } while ();

    if (((loop)->timercnt) && (((loop)->timers) [( - )]).at < ((loop)->mn_now))

    {

        do

        {

            ev_timer *w = (ev_timer *)(((loop)->timers) [( - )]).w;

            if (w->repeat)

            {

                ((WT)(w))->at += w->repeat;

                if (((WT)(w))->at < ((loop)->mn_now))

                    ((WT)(w))->at = ((loop)->mn_now);

                (__builtin_expect(!(("libev: negative ev_timer repeat value found while processing timers", w->repeat > .)), ) ? __assert_rtn(__func__, "ev.c", , "(\"libev: negative ev_timer repeat value found while processing timers\", w->repeat > 0.)") : (void));

                (((loop)->timers) [( - )]).at = (((loop)->timers) [( - )]).w->at;

                downheap (((loop)->timers), ((loop)->timercnt), ( - ));

            }

            else

                ev_timer_stop (loop, w);

            do { } while ();

            feed_reverse (loop, (W)w);

        }

        while (((loop)->timercnt) && (((loop)->timers) [( - )]).at < ((loop)->mn_now));

        feed_reverse_done (loop, EV_TIMER);

    }

}

static void __attribute__ ((__noinline__))

periodic_recalc (struct ev_loop *loop, ev_periodic *w)

{

    ev_tstamp interval = w->interval > 0.0001220703125 ? w->interval : 0.0001220703125;

    ev_tstamp at = w->offset + interval * floor ((((loop)->ev_rt_now) - w->offset) / interval);

    while (at <= ((loop)->ev_rt_now))

    {

        ev_tstamp nat = at + w->interval;

        if (__builtin_expect ((!!(nat == at)),()))

        {

            at = ((loop)->ev_rt_now);

            break;

        }

        at = nat;

    }

    ((WT)(w))->at = at;

}

static inline void

periodics_reify (struct ev_loop *loop)

{

    do { } while ();

    while (((loop)->periodiccnt) && (((loop)->periodics) [( - )]).at < ((loop)->ev_rt_now))

    {

        do

        {

            ev_periodic *w = (ev_periodic *)(((loop)->periodics) [( - )]).w;

            if (w->reschedule_cb)

            {

                ((WT)(w))->at = w->reschedule_cb (w, ((loop)->ev_rt_now));

                (__builtin_expect(!(("libev: ev_periodic reschedule callback returned time in the past", ((WT)(w))->at >= ((loop)->ev_rt_now))), ) ? __assert_rtn(__func__, "ev.c", , "(\"libev: ev_periodic reschedule callback returned time in the past\", ev_at (w) >= ev_rt_now)") : (void));

                (((loop)->periodics) [( - )]).at = (((loop)->periodics) [( - )]).w->at;

                downheap (((loop)->periodics), ((loop)->periodiccnt), ( - ));

            }

            else if (w->interval)

            {

                periodic_recalc (loop, w);

                (((loop)->periodics) [( - )]).at = (((loop)->periodics) [( - )]).w->at;

                downheap (((loop)->periodics), ((loop)->periodiccnt), ( - ));

            }

            else

                ev_periodic_stop (loop, w);

            do { } while ();

            feed_reverse (loop, (W)w);

        }

        while (((loop)->periodiccnt) && (((loop)->periodics) [( - )]).at < ((loop)->ev_rt_now));

        feed_reverse_done (loop, EV_PERIODIC);

    }

}

static void __attribute__ ((__noinline__))

periodics_reschedule (struct ev_loop *loop)

{

    int i;

    for (i = ( - ); i < ((loop)->periodiccnt) + ( - ); ++i)

    {

        ev_periodic *w = (ev_periodic *)(((loop)->periodics) [i]).w;

        if (w->reschedule_cb)

            ((WT)(w))->at = w->reschedule_cb (w, ((loop)->ev_rt_now));

        else if (w->interval)

            periodic_recalc (loop, w);

        (((loop)->periodics) [i]).at = (((loop)->periodics) [i]).w->at;

    }

    reheap (((loop)->periodics), ((loop)->periodiccnt));

}

static void __attribute__ ((__noinline__))

timers_reschedule (struct ev_loop *loop, ev_tstamp adjust)

{

    int i;

    for (i = ; i < ((loop)->timercnt); ++i)

    {

        ANHE *he = ((loop)->timers) + i + ( - );

        (*he).w->at += adjust;

        (*he).at = (*he).w->at;

    }

}

static inline void

time_update (struct ev_loop *loop, ev_tstamp max_block)

{

    {

        ((loop)->ev_rt_now) = ev_time ();

        if (__builtin_expect ((!!(((loop)->mn_now) > ((loop)->ev_rt_now) || ((loop)->ev_rt_now) > ((loop)->mn_now) + max_block + .)),()))

        {

            timers_reschedule (loop, ((loop)->ev_rt_now) - ((loop)->mn_now));

            periodics_reschedule (loop);

        }

        ((loop)->mn_now) = ((loop)->ev_rt_now);

    }

}