LCOM1920-T5G03

        uint16_t W = 0, H = 0; {

            for(size_t i = 0; i < len; ++i){

                const glyph_t *g = p->fnt->glyphs[(size_t)p->txt[i]];

            }

        }

        uint8_t *alp_buf = malloc(W*H);

void (sprite_set_pos)   (sprite_t *p, int16_t x , int16_t y ){ p->x = x; p->y = y; }

void (sprite_set_angle) (sprite_t *p, double angle          ){ p->theta = angle; p->c = fm_cos(p->theta); p->s = fm_sin(p->theta); }

void (sprite_set_scale) (sprite_t *p, double scale          ){

    p->scale = scale;

    p->su0 = (int16_t)(p->bsp->u0*p->scale);

        sprite_sbuf2src(p, 0          , 0          , &x, &y);

        xmin = x; xmax = x; ymin = y; ymax = y;

        sprite_sbuf2src(p, (int16_t)sw, 0          , &x, &y);

        sprite_sbuf2src(p, 0          , (int16_t)sh, &x, &y);

        sprite_sbuf2src(p, (int16_t)sw, (int16_t)sh, &x, &y);

    }

    const uint16_t bytes_pixel = 3/*graph_get_bytes_pixel()*/;

    for(int16_t u, v, y = ymin; y < ymax; ++y){

static void (rectangle_draw_hline)(int16_t x, int16_t y, int16_t l, uint32_t color){

    if(l < 0){ rectangle_draw_hline(x+l, y, -l, color); return; }

        graph_set_pixel((uint16_t)x_, (uint16_t)y, color);

    }

}

static void (rectangle_draw_vline)(int16_t x, int16_t y, int16_t l, uint32_t color){

    if(l < 0){ rectangle_draw_vline(x, y+l, -l, color); return; }

        graph_set_pixel((uint16_t)x, (uint16_t)y_, color);

    }

}

void (rectangle_draw)(const rectangle_t *p){

    /// fill

    if(p->fill_alpha > ALPHA_THRESHOLD)

            rectangle_draw_hline(p->x, y, (int16_t)p->w, p->fill_color);

    /// border

    int16_t step = (p->outline_width > 0 ? 1 : -1);

 * @{

 */

#define COM1_ADDR           0x3F8

#define COM2_ADDR           0x2F8

#define COM1_IRQ            4

#define COM2_IRQ            3

#define COM1_VECTOR         0x0C

#define COM2_VECTOR         0x0B

typedef enum {

    uart_parity_none = 0x0,

    uart_parity_odd  = 0x1,

    uart_parity_par0 = 0x7

} uart_parity;

typedef struct {

    int     base_addr               ;

    uint8_t lcr                     ;

    uint8_t dll                     ;

    uint8_t dlm                     ;

    uint8_t bits_per_char           ;

    uint8_t stop_bits               ;

    uart_parity parity              ;

    uint8_t break_control         :1;

    uint8_t dlab                  :1;

    uint16_t divisor_latch          ;

    uint8_t ier                     ;

    uint8_t received_data_int     :1;

    uint8_t transmitter_empty_int :1;

    uint8_t receiver_line_stat_int:1;

    uint8_t modem_stat_int        :1;

} uart_config;

 * @param b     Second value

 * @return  The minimum of the two values

 */

/**

 * @brief Gets the maximum value out of two values.

 * @param b     Second value

 * @return  The maximum of the two values

 */

/**

 * @brief Get the absolute value of a double.

 * @param   a   Argument

 * @return      Absolute value of a

 */

/**

 * @brief Compare if two doubles are approximately equal (within 1e-10).

 * @param   b   Second value

 * @return      true if the two numbers are approximately equal, false otherwise

 */

/**

 * @}

    return SUCCESS;

}

int32_t min32(int32_t a, int32_t b){ return (b < a ? b : a); }

double  dmin (double  a, double  b){ return (b < a ? b : a); }

int32_t max32(int32_t a, int32_t b){ return (a < b ? b : a); }

    else return false;

}

int (map_collides_gunner)(const map_t *p, const gunner_t *shooter) {

    return map_collides_gunner_pos(p, gunner_get_x(shooter), gunner_get_y(shooter), radius);

}

int (map_make_dijkstra)(map_t *p, double x_, double y_){

}

int (map_collides_bullet)(const map_t *p, const bullet_t *bull){

    double bullet_x = bullet_get_x(bull);

    double bullet_y = bullet_get_y(bull);

    for (double x = -radius; x < radius; x += 1){

int (gunner_collides_bullet)(const gunner_t *shooter, const bullet_t *bull){

    if(bull->shooter == shooter) return false;

    double shooter_x = gunner_get_x(shooter);

    double shooter_y = gunner_get_y(shooter);

    double bullet_x = bullet_get_x(bull);

    double bullet_y = bullet_get_y(bull);

int (gunner_collides_gunner)(const gunner_t *shooter1, const gunner_t *shooter2) {

    if (shooter1 == shooter2) return false;

    double distance = distance_gunners(shooter1, shooter2);

    return distance <= shooter1_radius+shooter2_radius;

}

static int16_t mouse_x = 0, mouse_y = 0;

void (update_mouse)(struct packet *p) {

    key_presses.lb_pressed = p->lb;

}