static void ss_reconfig(ss_t *s, size_t new_alloc_size, const size_t new_mt_sz)
{
	size_t size = sd_get_size(s), unicode_size = get_unicode_size(s);
	char *s_str = get_str(s);
	/* Compute offset on target location: */
	struct SSTR_Small sm;
	struct SSTR_Full sf;
	const size_t s2_off = new_mt_sz == SS_METAINFO_SMALL?
				sm.str -(char *)&sm : sf.str - (char *)&sf;
	/* Convert string: */
	memmove((char *)s + s2_off, s_str, size);
	s->is_full = sd_alloc_size_to_is_big(new_alloc_size, &ssf);
	set_size(s, size);
	set_alloc_size(s, new_alloc_size);
	set_unicode_size(s, unicode_size);
}

/*
 * clique_unweighted_max_weight()
 *
 * Returns the size of the maximum (sized) clique in g (or 0 if search
 * was aborted).
 *
 *   g    - the graph
 *   opts - time printing options
 *
 * Note: As we don't have an algorithm faster than actually finding
 *       a maximum clique, we use clique_unweighted_find_single().
 *       This incurs only very small overhead.
 */
int clique_unweighted_max_weight(graph_t *g, clique_options *opts) {
	set_t s;
	int size;

	ASSERT((sizeof(setelement)*8)==ELEMENTSIZE);
	ASSERT(g!=NULL);

	s=clique_unweighted_find_single(g,0,0,FALSE,opts);
	if (s==NULL) {
		/* Search was aborted. */
		return 0;
	}
	size=set_size(s);
	set_free(s);
	return size;
}

RadioButton::RadioButton (const RefPtr<AbstractIcon>& icon)
    : AbstractButton(icon)
{
  set_round_type(RoundAll);
  set_checkable(true);

  int w = this->icon()->size().width();
  int h = this->icon()->size().height();

  w += pixel_size(kPadding.hsum());
  h += pixel_size(kPadding.vsum());

  set_size(w, h);

  InitializeRadioButtonOnce();
}

/**
 * \brief Creates a carried item (i.e. an item carried by the hero).
 * \param hero the hero who is lifting the item to be created
 * \param original_entity the entity that will be replaced by this carried item
 * (its coordinates, size and origin will be copied)
 * \param animation_set_id name of the animation set for the sprite to create
 * \param destruction_sound_id Name of the sound to play when this item is destroyed
 * (or an empty string).
 * \param damage_on_enemies damage received by an enemy if the item is thrown on him
 * (possibly 0)
 * \param explosion_date date of the explosion if the item should explode,
 * or 0 if the item does not explode
 */
CarriedItem::CarriedItem(
    Hero& hero,
    const Entity& original_entity,
    const std::string& animation_set_id,
    const std::string& destruction_sound_id,
    int damage_on_enemies,
    uint32_t explosion_date
):
  Entity("", 0, hero.get_layer(), Point(0, 0), Size(0, 0)),
  hero(hero),
  is_lifting(true),
  is_throwing(false),
  is_breaking(false),
  break_one_layer_above(false),
  destruction_sound_id(destruction_sound_id),
  damage_on_enemies(damage_on_enemies),
  shadow_sprite(nullptr),
  throwing_direction(0),
  next_down_date(0),
  item_height(0),
  y_increment(0),
  explosion_date(explosion_date) {

  // align correctly the item with the hero
  int direction = hero.get_animation_direction();
  if (direction % 2 == 0) {
    set_xy(original_entity.get_x(), hero.get_y());
  }
  else {
    set_xy(hero.get_x(), original_entity.get_y());
  }
  set_origin(original_entity.get_origin());
  set_size(original_entity.get_size());
  set_drawn_in_y_order(true);

  // create the lift movement and the sprite
  std::shared_ptr<PixelMovement> movement = std::make_shared<PixelMovement>(
      lifting_trajectories[direction], 100, false, true
  );
  create_sprite(animation_set_id);
  get_sprite().set_current_animation("stopped");
  set_movement(movement);

  // create the shadow (not visible yet)
  shadow_sprite = std::make_shared<Sprite>("entities/shadow");
  shadow_sprite->set_current_animation("big");
}

/* graph_rem_veterx */
int graph_rem_vertex(Graph *graph, void **data) {
	ListElmt *element, *temp, *prev;
	AdjList *adjlist;
	int found;

	/* Traverse each adjacency list and the vertices it contains. */
	prev = NULL;
	found = 0;

	for (element = list_head(&graph->adjlists); element != NULL;
		 element = list_next(element)) {
		/* Do not allow removal of the vertex if it is in an adjacenty list. */
		if (set_is_member(&((AdjList *)list_data(element))->adjacent, *data))
			return -1;

		/* Keep a pointer to the vertex to be removed. */
		if (graph->match(*data, ((AdjList *)list_data(element))->vertex)) {
			temp = element;
			found = 1;
		}

		/* Keep a pointer to the vertex before the vertex to be removed. */
		if (!found)
			prev = element;
	}

	/* Return if the vertex was not found. */
	if (!found)
		return -1;

	/* Do not allow removal of the vertex if its adjacency list is not empty. */
	if (set_size(&((AdjList *)list_data(temp))->adjacent) > 0)
		return -1;

	/* Remove the vertex. */
	if (list_rem_next(&graph->adjlists, prev, (void **)&adjlist) != 0)
		return -1;

	/* Free the storage allocated by the abstract datatype. */
	*data = adjlist->vertex;
	free(adjlist);

	/* Adjust the vertex count to account for the removed vertex. */
	graph->vcount--;
	return 0;
}

Asteroid::Asteroid(float x, float y, float ang, float xv, float yv, float rv, int s)
{
    xPos = x;
    yPos = y;
    Collider.x = xPos;
    Collider.y = yPos;
    Angle = ang;
    xVel = xv;
    yVel = yv;
    rotVel = rv;
    split_num = 3;
    mass_max = 90;
    powerup_chance = 10;
    set_size(s);

    TYPE = T_ASTEROID;
}

TiXmlString& TiXmlString::assign(const char* str, size_type len)
{
	size_type cap = capacity();
	if (len > cap || cap > 3*(len + 8))
	{
		TiXmlString tmp;
		tmp.init(len);
		std::memcpy(tmp.start(), str, len);
		swap(tmp);
	}
	else
	{
		std::memmove(start(), str, len);
		set_size(len);
	}
	return *this;
}

void setup(){
    set_brief("How to make a basic sword");
    set_long(@MAY

Inherit the appropriate file - SWORD, M_VALUABLE.
Normal setup for adj, size and value (id not needed).
Set weapon_class - approx max hps of damage from a hit.

inherit SWORD;
inherit M_VALUABLE;

void setup() {
    set_adj("dull");
    set_weapon_class(15);
    set_size(MEDIUM);
    set_value(1000);
}

void setup(void) {
   set_id("crown");
   set_adj("metal");
   set_short("A metal crown");
   set_long("This crown functions as a useful helmet." +
      " It is a simple crown of metal but you know that it's ancient " +
      "and has rested upon the heads of champions throughout the " +
      "ages.");
   set_gettable(1);
   set_slot("head");
   set_wear_message("$N $vdon $o.");
   set_remove_message("$N $vtake off $o");
   set_ac(2);
   set_value(3000);
   set_size(3);
   set_weight(1);
}

bool vsx_widget_note::init_from_command(vsx_command_s* c)
{
  set_render_type(render_3d);
  vsx_vector3<> np;
  np = vsx_vector3_helper::from_string<float>(c->parts[2]);
  set_pos(np);
  np = vsx_vector3_helper::from_string<float>(c->parts[3]);
  set_size(np);
  set_font_size(vsx_string_helper::s2f(c->parts[5]));
  set_border(font_size*0.15f);
  size_min.x = font_size*3.0f;
  size_min.y = font_size*4.0f;

  //new_note->target_size = new_note->size;
  load_text( vsx_string_helper::base64_decode(c->parts[4]));
  return true;
}

void set_to_xml(int *l, char* res) /* prints the content of a set */
{
  int i, j, start = 1;

  for(i = 0; i < set_size(4); i++) {
    for(j = 0; j < mod; j++){
      if(l[i] & (1 << j)) {
        if(!start) strcat(res, ",");
        char tmp[8];
        sprintf(tmp, "z[%i]=0", mod * i + j);
        strcat(res,tmp);

        start = 0;
      }
    }
  }
}

/**
 * \brief Creates an enemy.
 * \param game The game.
 * \param name Id of the enemy.
 * \param layer The layer on the map.
 * \param x X position on the map.
 * \param y Y position on the map.
 * \param breed Breed of the enemy.
 * \param treasure Treasure dropped when the enemy is killed.
 */
Enemy::Enemy(
    Game& game,
    const std::string& name,
    Layer layer,
    int x,
    int y,
    const std::string& breed,
    const Treasure& treasure):

  Detector(COLLISION_RECTANGLE | COLLISION_SPRITE,
      name, layer, x, y, 0, 0),

  breed(breed),
  damage_on_hero(1),
  magic_damage_on_hero(0),
  life(1),
  hurt_style(HURT_NORMAL),
  pushed_back_when_hurt(true),
  push_hero_on_sword(false),
  can_hurt_hero_running(false),
  minimum_shield_needed(0),
  rank(RANK_NORMAL),
  savegame_variable(),
  traversable(true),
  obstacle_behavior(OBSTACLE_BEHAVIOR_NORMAL),
  drawn_in_y_order(true),
  initialized(false),
  being_hurt(false),
  stop_hurt_date(0),
  invulnerable(false),
  vulnerable_again_date(0),
  can_attack(true),
  can_attack_again_date(0),
  immobilized(false),
  start_shaking_date(0),
  end_shaking_date(0),
  dying_animation_started(false),
  treasure(treasure),
  exploding(false),
  nb_explosions(0),
  next_explosion_date(0) {

  set_size(16, 16);
  set_origin(8, 13);
}

/**
 * @brief Creates a carried item (i.e. an item carried by the hero).
 * @param hero the hero who is lifting the item to be created
 * @param original_entity the entity that will be replaced by this carried item
 * (its coordinates, size and origin will be copied)
 * @param animation_set_id name of the animation set for the sprite to create
 * @param destruction_sound_id name of the sound to play when this item is destroyed
 * (or an empty string)
 * @param damage_on_enemies damage received by an enemy if the item is thrown on him
 * (possibly 0)
 * @param explosion_date date of the explosion if the item should explode,
 * or 0 if the item does not explode
 */
CarriedItem::CarriedItem(Hero& hero, MapEntity& original_entity,
    const std::string& animation_set_id,
    const std::string& destruction_sound_id,
    int damage_on_enemies, uint32_t explosion_date):

  MapEntity(),
  hero(hero),
  is_lifting(true),
  is_throwing(false),
  is_breaking(false),
  break_on_intermediate_layer(false) {

  // put the item on the hero's layer
  set_layer(hero.get_layer());

  // align correctly the item with the hero
  int direction = hero.get_animation_direction();
  if (direction % 2 == 0) {
    set_xy(original_entity.get_x(), hero.get_y());
  }
  else {
    set_xy(hero.get_x(), original_entity.get_y());
  }
  set_origin(original_entity.get_origin());
  set_size(original_entity.get_size());

  // create the lift movement and the sprite
  PixelMovement *movement = new PixelMovement(lifting_trajectories[direction], 100, false, true);
  create_sprite(animation_set_id);
  get_sprite().set_current_animation("stopped");
  set_movement(movement);

  // create the breaking sound
  this->destruction_sound_id = destruction_sound_id;

  // create the shadow (not visible yet)
  this->shadow_sprite = new Sprite("entities/shadow");
  this->shadow_sprite->set_current_animation("big");

  // damage on enemies
  this->damage_on_enemies = damage_on_enemies;

  // explosion
  this->explosion_date = explosion_date;
}

/*ARGSUSED*/
    static void
Initialize(Widget rq, Widget ebw, ArgList args, Cardinal *n)
{
    XmEnhancedButtonWidget  request = (XmEnhancedButtonWidget)rq;
    XmEnhancedButtonWidget  eb = (XmEnhancedButtonWidget)ebw;
    XtWidgetProc	    resize;

    XtProcessLock();
    resize = xmLabelClassRec.core_class.resize;
    XtProcessUnlock();

    /* Create a bitmap for stippling (Drawable resources are cheap).  */
    if (STIPPLE_BITMAP == None)
    {
	Display *dpy = XtDisplay((Widget) request);
	Window	rootW = DefaultRootWindow(dpy);

	STIPPLE_BITMAP = XCreateBitmapFromData(dpy, rootW, stipple_bits,
		stipple_width, stipple_height);
    }
    eb->enhancedbutton.doing_setvalues = False;

    /* First see what type of extended label this is.
     */
    if (eb->enhancedbutton.pixmap_data)
    {
	XmString str;
	set_pixmap(eb);

	/* FIXME: this is not the perfect way to deal with menues, which do not
	 * have any string set right now.  */
	str = XmStringCreateLocalized("");
	XtVaSetValues((Widget) eb, XmNlabelString, str, NULL);
	XmStringFree(str);
    }
    eb->label.pixmap = eb->enhancedbutton.normal_pixmap;

    if (request->core.width == 0)
	eb->core.width = 0;
    if (request->core.height == 0)
	eb->core.height = 0;
    set_size(eb);

    (* resize)((Widget)eb);
}

Unison::Unison(int update_period_samples_, REALTYPE max_delay_sec_) {
    update_period_samples = update_period_samples_;
    max_delay    = (int)(max_delay_sec_ * (REALTYPE)SAMPLE_RATE + 1);
    if(max_delay < 10)
        max_delay = 10;
    delay_buffer = new REALTYPE[max_delay];
    delay_k      = 0;
    base_freq    = 1.0;
    unison_bandwidth_cents = 10.0;

    ZERO_REALTYPE(delay_buffer, max_delay);

    uv = NULL;
    update_period_sample_k = 0;
    first_time = 0;

    set_size(1);
}

static boolean callback_callback(set_t s, graph_t *g, clique_options *opt) {
    igraph_vector_t *clique;
    struct callback_data *cd;
    int i, j;

    CLIQUER_ALLOW_INTERRUPTION();

    cd = (struct callback_data *) opt->user_data;

    clique = (igraph_vector_t *) malloc(sizeof(igraph_vector_t));
    igraph_vector_init(clique, set_size(s));

    i = -1; j = 0;
    while ((i = set_return_next(s,i)) >= 0)
        VECTOR(*clique)[j++] = i;

    return (*(cd->handler))(clique, cd->arg);
}

	FileButton::FileButton ()
	: AbstractButton(String("...")),
	  dialog_(0)
	{
		set_round_type(RoundAll);

		int h = this->text()->font().height();
		int w = h;

		w += pixel_size(kPadding.hsum());
		h += pixel_size(kPadding.vsum());

		set_size(w, h);

		InitializeFileButtonOnce();

		clicked().connect(this, &FileButton::OnClicked);
	}

vsx_widget_controller_pad::vsx_widget_controller_pad()
{
    widget_type = 0;
    a.x = 0;
    a.y = 0;

    b.x = 1;
    b.y = 1;

    widget_type = VSX_WIDGET_TYPE_CONTROLLER;
    coord_type = VSX_WIDGET_COORD_CENTER;
    set_size(vsx_vector3<>(0.1,0.1));
    set_pos(vsx_vector3<>(-0.06));

    generate_menu();
    menu->init();
    drawing = false;
}

void dfree(void* ptr, int flag) {

	/* Your free and coalescing code goes here */
	//bool left_f = is_free(left_block(ptr));
	bool right_f = is_free(to_meta(right_block(ptr)));
	bool left_f = is_free((metadata_t *)(ptr - META_SIZE - FOOTER_SIZE));
	
	if (!left_f && !right_f) {
	    set_free(to_meta(ptr));
	    set_free((metadata_t *)to_footer(ptr));
	    add_node(to_meta(ptr));
	}
	else if (left_f && !right_f) {
		//process the linked list
		//change the size of two blocks
		delete_node(to_meta(left_block(ptr)));
		int left_size = block_size(left_block(ptr));
		int new_size = left_size + FOOTER_SIZE + META_SIZE + block_size(ptr);
		set_size(to_meta(left_block(ptr)), new_size);
		set_size((metadata_t *)to_footer(ptr), new_size);
		set_free(to_meta(left_block(ptr)));
		set_free((metadata_t *)to_footer(ptr));
		add_node(to_meta(left_block(ptr)));
	}
	else if (!left_f && right_f) {
		//process the linked list
		delete_node(to_meta(right_block(ptr)));
		//change the size of two blocks
		int right_size = block_size(right_block(ptr));
		int new_size = right_size + block_size(ptr) + FOOTER_SIZE + META_SIZE;
		set_size((metadata_t *)to_footer(right_block(ptr)), new_size);
		set_free((metadata_t *)to_footer(right_block(ptr)));
		set_size(to_meta(ptr), new_size);
		set_free(to_meta(ptr));
		//process the linked list
		add_node(to_meta(ptr));
	}
	else if (left_f && right_f) {
		//process the linked list
		delete_node(to_meta(right_block(ptr)));
		delete_node(to_meta(left_block(ptr)));
		//change the size of two blocks
		int right_size = block_size(right_block(ptr));
		int left_size = block_size(left_block(ptr));
		int new_size = block_size(ptr) + left_size + right_size + 2 * (FOOTER_SIZE + META_SIZE);
		set_size((metadata_t *)to_footer(right_block(ptr)), new_size);
		set_free((metadata_t *)to_footer(right_block(ptr)));
		set_size(to_meta(left_block(ptr)), new_size);
		set_free(to_meta(left_block(ptr)));	
		add_node(to_meta(left_block(ptr)));
	}
}

void setup() {
  add_relation("in");
  set_default_relation("in");
  set_gettable("It is securely anchored.\n");
  set_id("mailbox", "box");
  set_adj("small");
  set_in_room_desc("There is a small mailbox here.");
  set_max_capacity(SMALL);
#ifdef USE_SIZE
  set_size(MEDIUM);
#endif
#ifdef USE_MASS
  set_mass(MEDIUM);
#endif
  set_objects( ([
		 "leaflet" : 1
  ]) );
}