DELTA 13744 42947 636
SVN  ÊSÐ
…/ Ê2 €…/8Êcase PACKET_VOTE_NEW:
    handle_vote_new(packet);
    return TRUE;

  case PACKET_VOTE_UPDATE:
    handle_vote_update(
      ((struct packet_vote_update *)packet)->vote_no,
      ((struct packet_vote_update *)packet)->yes,
      ((struct packet_vote_update *)packet)->no,
      ((struct packet_vote_update *)packet)->abstain,
      ((struct packet_vote_update *)packet)->num_voters);
    return TRUE;

  case PACKET_VOTE_REMOVE:
    handle_vote_remove(
      ((struct packet_vote_remove *)packet)->vote_no);
    return TRUE;

  case PACKET_VOTE_RESOLVE:
    handle_vote_resolve(
      ((struct packet_vote_resolve *)packet)->vote_no,
      ((struct packet_vote_resolve *)packet)->passedENDREP
DELTA 13744 47128 168
SVN  ¬j®f‚ ¬I €‚struct packet_vote_new;
void handle_vote_new(struct packet_vote_new *packet);
void handle_vote_update(int vote_no, int yes, int no, int abstain, int num_voters);
void handle_vote_remove(int vote_no);
void handle_vote_resolve(int vote_no, bool passed);

#endif /* FC__PACKHAND_GEN_H */
ENDREP
DELTA 14495 0 34512
SVN  †  †  … ×) €‚n Â×€‚' …*™,case PACKET_VOTE_NEW:
    return receive_packet_vote_new(pc, type);

  case PACKET_VOTE_UPDATE:
    return receive_packet_vote_update(pc, type);

  case PACKET_VOTE_REMOVE:
    return receive_packet_vote_remove(pc, type);

  case PACKET_VOTE_RESOLVE:
    return receive_packet_vote_resolve(pc, type);

  case PACKET_VOTE_SUBMIT:
    return receive_packet_vote_submitcase PACKET_VOTE_NEW:
    return "PACKET_VOTE_NEW";

  case PACKET_VOTE_UPDATE:
    return "PACKET_VOTE_UPDATE";

  case PACKET_VOTE_REMOVE:
    return "PACKET_VOTE_REMOVE";

  case PACKET_VOTE_RESOLVE:
    return "PACKET_VOTE_RESOLVE";

  case PACKET_VOTE_SUBMIT:
    return "PACKET_VOTE_SUBMIT†  †  †  „;€„ AƒÚ?¸ RƒÜz †š2$s_phases);
  if(differ) {different++;}
  if(packet->simultaneous_phases) {BV_SET(fields, 11);}

  differ = (old->num_phases != real_packet->num_phases);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 12);}

  differ = (old->min_players != real_packet->min_players);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 13);}

  differ = (old->max_players != real_packet->max_players);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 14);}

  differ = (old->nplayers != real_packet->nplayers);  differ = (old->player_idx != real_packet->player_idx);ŒÀ †  †  „|Ÿ7€‚L S‡< M‚€}€B e´=— ‚Ìw  ‰5‚Ìx¯ r‚×:· Y…÷>¾ u‚ß}€Q Y…÷>· ‚Û@‚ Y…÷>€ [‚Û@€h M‚ß} Z…—:„ ‚ã3ƒ …ø‡ …ù/… c…ú@ b‚æ0 Z…—: ^…üg g‚è[ Y…÷>‹ ‚ë;Œ …ÿ@¹ Y…÷>€j [‚Û?€Q s‚ñ ¼ Y…÷>» […—9€A y‚óJ n‚ß| ‚õ1 Ž	‚öE€q wƒ„8 ƒ…0 ƒƒ†6 wƒ‰Q€q kƒ‹9‚ ~ƒŒ% ƒ$ zƒŽ) ~ƒ$ aƒ†6 Wƒ’ lƒ“\€l rƒ•4 p„…m ƒ—‚ ƒ˜ ƒ™  zƒš% |ƒ›  zƒœ vƒ 
ƒž 
ƒŸ k†—'‚ ƒ¡‚  ƒ¢ 
ƒ£ ƒ¤ fƒ†6œ ƒˆ>‚ ‚Mƒ¨9 i„Ì} ‚Nƒ«p€ Zƒ¯( oƒÂ' Qƒ°r€ƒN oƒÂ' Zƒµ€ Qƒ·x€- [ƒ¹v€] Uƒ».€‚/ Rƒ¾2ž Eƒ¿{€ ^ƒÀn€[ ?ƒÂ' ƒoƒÃg¨ T‚È6 ‚a‚Ê€P A„›® RÖ> ‚‚Î} lñp ¨{‚Ò ‚û ‚6‚ü" u…Æ  È$ƒ€j€y F¤  „FƒÉm¯ UË; „ƒÎx¬ E„—  ÃƒÓ: send_packet_city_make_specialist(pc, real_packet);
}

#define hash_packet_city_make_worker_100 hash_const

#define cmp_packet_city_make_worker_100 cmp_const

BV_DEFINE(packet_city_make_worker_100_fields, 3);

static struct packet_city_make_worker *receive_packet_city_make_worker_100(struct connection *pc, enum packet_type type)
{make_worker *clone;
  RECEIVE_PACKET_START(packet_city_make_workermake_worker_100, cmp_pa6real_packet->was_created = BV_ISSET(fields, 4);government = readin;
    }
  }
  if (BV_ISSET(fields, 6target_government = readin;
    }
  }
  if (BV_ISSET(fields, 7bool8(&din, &real_packet->embassy[i]);
      }
    }
  }
  if (BV_ISSET(fields, 8city_style = readin;
    }
  }
  if (BV_ISSET(fields, 910team = readin;
    }
  }
  real_packet->is_ready = BV_ISSET(fields, 11);
  real_packet->phase_done = BV_ISSET(fields, 12);
  if (BV_ISSET(fields, 13turns_idle = readin;
    }
  }
  real_packet->is_alive = BV_ISSET(fields, 14);
  if (BV_ISSET(fields, 156goldtaxscienceluxur1bulbs_researched3researchingscience_costfuture_tech = readin;
    }
  }
  if (BV_ISSET(fields, 26tech_goal = readin;
    }
  }
  real_packet->is_connected = BV_ISSET(fields, 27);
  if (BV_ISSET(fields, 2revolution_finishes = readin;
    }
  }
  real_packet->ai = BV_ISSET(fields, 29);ai_skill_level = readin;
    }
  }
  if (BV_ISSET(fields, 31barbarian_type = readin;
    }
  }
  if (BV_ISSET(fields, 3gives_shared_vision = readin;
    }
  }
  if (BV_ISSET(fields, 335was_created != real_packet->was_created);
  if(differ) {different++;}
  if(packet->was_created) {BV_SET(fields, 45678);}

  differ = (old->nation != real_packet->nation);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 910123456);}

  differ = (old->tax != real_packet->tax);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 178920123456782930123love[i] != real_packet->love345/* field 4 is folded into the header */
  if (BV_ISSET(fields, 5)) {
    dio_put_uint8(&dout, real_packet->government);
  }
  if (BV_ISSET(fields, 678)) {
    dio_put_uint8(&dout, real_packet->city_style);
  }
  if (BV_ISSET(fields, 9)) {
    dio_put_sint16(&dout, real_packet->nation);
  }
  if (BV_ISSET(fields, 10)) {
    dio_put_uint8(&dout, real_packet->team);
  }
  /* field 11 is folded into the header */
  /* field 12 is folded into the header */
  if (BV_ISSET(fields, 13)) {
    dio_put_sint16(&dout, real_packet->nturns_idle);
  }
  /* field 14 is folded into the header */
  if (BV_ISSET(fields, 156)) {
    dio_put_uint32(&dout, real_packet->gold);
  }
  if (BV_ISSET(fields, 17)) {
    dio_put_uint8(&dout, real_packet->tax);
  }
  if (BV_ISSET(fields, 189)) {
    dio_put_uint8(&dout, real_packet->luxury);
  }
  if (BV_ISSET(fields, 20)) {
    dio_put_uint16(&dout, real_packet->bulbs_last_turn);
  }
  if (BV_ISSET(fields, 212)) {
    dio_put_uint32(&dout, real_packet->techs_researched);
  }
  if (BV_ISSET(fields, 234)) {
    dio_put_uint16(&dout, real_packet->science_cost);
  }
  if (BV_ISSET(fields, 25)) {
    dio_put_uint16(&dout, real_packet->future_tech);
  }
  if (BV_ISSET(fields, 26)) {
    dio_put_uint8(&dout, real_packet->tech_goal);
  }
  /* field 27 is folded into the header */
  if (BV_ISSET(fields, 289 is folded into the header */ai_skill_level);
  }
  if (BV_ISSET(fields, 31)) {
    dio_put_uint8(&dout, real_packet->barbarian_type);
  }
  if (BV_ISSET(fields, 323)) {
    dio_put_bit_string(&dout, real_packet->inventions);
  }
  if (BV_ISSET(fields, 345unsigned int hash_packet_player_info_10111_fields, 35);

static struct packet_player_info *receive_packet_player_info_101info_101_fields fields;
  struct packet_player1, cmp_packet_player_info_101111, cmp_packet_player_info_101(has_capability("CreatedName", pc->capability) && has_capability("CreatedName", our_capability))) {
    variant = 100;
  } else if(!(has_capability("CreatedName", pc->capability) && has_capability("CreatedName", our_capability))) {
    variant = 101case 101: return receive_packet_player_info_101case 101: return send_packet_player_info_101’à †  †  ƒwº
€B ]…Ý@€% bƒ®t€v Fƒî@€‚ ‚¡@€ƒ ~“@ S…Á© SƒÂ<© D…ž~€I v…êp€C _ƒ÷@€‚6 ò€ K¯– è €q s†•|€. Y…Í:€X J‚ù~€+ I„Ê?€G D†|´ S†ƒ · f„Ð|¢ ƒwƒ† €I ‚¡@€  ~“@ ƒi‚ƒ}† P¯† è €J x†•{€k ^…Í:½ N‚ù~€i I„Ê?€‚+ b…Šr€…& 
ÀC€O C†}± R÷}® GÄ:ž pƒ†  „RÇ® 1Ì€H Y…“?± [„Ó@ ÑZ‰ bÒy€U Y…“?² Y…“?¼ Y…“?€v aƒ³<€E Y…“?´ Y…“?¹ Y…“?¹ Y…“?¶ ZÑ ½ y‚ãy€K ZÑ » ZÑ €e wƒ±|§ A“  Pƒ«< Cƒ± €A wƒ±|§ A“  Pƒ«<€	 wƒ±|§ A“  Pƒ«<¬ Qƒî:€? ‚¡@€ ‚“:› S…Á =¾y° Eß\€J 0ã€q kß- æ€a gä)€ …–K     dio_get_uint32(&din, &readin);
      real_packet->total_lengthuint32(&din, &readin);
      real_packet->chunk_length = readin;
    }
  }
  if (BV_ISSET(fields, 3)) {
    
      if(real_packet->chunk_length > ATTRIBUTE_CHUNK_SIZchunk_length = ATTRIBUTE_CHUNK_SIZE;
      }
      dio_get_memory(&din, real_packet->data, real_packet->chunk_length);player_attribute_chunk_100(struct connection *pc, const struct packet_player_attribute_chunk *packet)
{
  const struct packet_player_attribute_chunk *real_packet = packet;
  packet_player_attribute_chunk_100_fields fields;
  struct packet_player_attribute_chunkPLAYER_ATTRIBUTE_CHUNK];
  int different = 0;
  SEND_PACKET_START(PACKET_PLAYER_ATTRIBUTE_CHUNK);

  {
    struct packet_player_attribute_chunk *tmp = fc_malloc(sizeof(*tmp));

    *tmp = *packet;
    pre_send_packet_player_attribute_chunk(pc, tmp);
    real_packet = tmp;
  }

  if (!*hash) {
    *hash = hash_new(hash_packet_player_attribute_chunk_100, cmp_packet_player_attribute_chunkoffset != real_packet->offsettotal_length != real_packet->total_lengthchunk_length != real_packet->chunk_lengthdiffer = (memcmp(old->data, real_packet->data, ATTRIBUTE_CHUNK_SIZE) != 0
  if (real_packet != packet) {
    free((void *) real_packet);
  }32(&dout, real_packet->offset);
  }
  if (BV_ISSET(fields, 1)) {
    dio_put_uint32(&dout, real_packet->total_length);
  }
  if (BV_ISSET(fields, 2)) {
    dio_put_uint32(&dout, real_packet->chunk_length);
  }
  if (BV_ISSET(fields, 3)) {
    dio_put_memory(&dout, &real_packet->data, real_packet->chunk_length
  if (real_packet != packet) {
    free((void *) real_packet);
  }
  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_player_attribute_chunkPLAYER_ATTRIBUTE_CHUNKPLAYER_ATTRIBUTE_CHUNK] = variant;
}

struct packet_player_attribute_chunk *receive_packet_player_attribute_chunkensure_valid_variant_packet_player_attribute_chunk(pc);

  switch(pc->phs.variant[PACKET_PLAYER_ATTRIBUTE_CHUNK]) {
    case 100: return receive_packet_player_attribute_chunkplayer_attribute_chunk(struct connection *pc, const struct packet_player_attribute_chunkensure_valid_variant_packet_player_attribute_chunk(pc);

  switch(pc->phs.variant[PACKET_PLAYER_ATTRIBUTE_CHUNK]) {
    case 100: return send_packet_player_attribute_chunk#define hash_packet_unit_remove_100 hash_const

#define cmp_packet_unit_remove_100 cmp_const

BV_DEFINE(packet_unit_remove_100_fields, 1);

static struct packet_unit_remove *receive_packet_unit_removremove_100_fields fields;
  struct packet_unit_removremove *clone;
  RECEIVE_PACKET_START(packet_unit_removremove_100, cmp_packet_unit_removeremove_100(struct connection *pc, const struct packet_unit_remove *packet)
{
  const struct packet_unit_remove *real_packet = packet;
  packet_unit_remove_100_fields fields;
  struct packet_unit_removeREMOVE];
  int different = 0;
  SEND_PACKET_START(PACKET_UNIT_REMOVE);

  if (!*hash) {
    *hash = hash_new(hash_packet_unit_remove_100, cmp_packet_unit_removeremoveREMOVEREMOVE] = variant;
}

struct packet_unit_remove *receive_packet_unit_removpc->is_server) {
    freelog(LOG_ERROR, "Receiving packet_unit_remove at the server.");
  }
  ensure_valid_variant_packet_unit_remove(pc);

  switch(pc->phs.variant[PACKET_UNIT_REMOVE]) {
    case 100: return receive_packet_unit_removeremove(struct connection *pc, const struct packet_unit_remove!pc->is_server) {
    freelog(LOG_ERROR, "Sending packet_unit_remove from the client.");
  }
  ensure_valid_variant_packet_unit_remove(pc);

  switch(pc->phs.variant[PACKET_UNIT_REMOVE]) {
    case 100: return send_packet_unit_removevoid lsend_packet_unit_remove(struct conn_list *dest, const struct packet_unit_remove *packet)
{
  conn_list_iterate(dest, pconn) {
    send_packet_unit_remove(pconn, packet);
  } conn_list_iterate_end;
}

int dsend_packet_unit_remove(struct connection *pc, int unit_id)
{
  struct packet_unit_removremove(pc, real_packet);
}

void dlsend_packet_unit_remove(struct conn_list *dest, int unit_id)
{
  struct packet_unit_remove packet, *real_packet = &packet;

  real_packet->unit_id = unit_id;
  
  lsend_packet_unit_remove(dest, real_packet);
}

static unsigned int hash_packet_unit_info_100(const void *vkey, unsigned int num_buckets)
{
  const struct packet_unit_info *key = (const struct packet_unit_info *) vkey;

  return ((key->id) % num_buckets);
}

static int cmp_packet_unit_info_100(const void *vkey1, const void *vkey2)
{
  const struct packet_unit_info *key1 = (const struct packet_unit_info *) vkey1;
  const struct packet_unit_info *key2 = (const struct packet_uniinfo_100_fields, 31);

static struct packet_unit_info *receive_packet_unit_infoinfo_100_fields fields;
  struct packet_unit_infoinfo *clone;
  RECEIVE_PACKET_START(packet_uniinfo_100, cmp_packet_unit_info16(&din, &readin);
      real_packet->homecityai = BV_ISSET(fields, 5);
  real_packet->paradropped = BV_ISSET(fields, 6);
  real_packet->transported = BV_ISSET(fields, 7);
  real_packet->done_moving = BV_ISSET(fields, 8);
  if (BV_ISSET(fields, 9type = readin;
    }
  }
  if (BV_ISSET(fields, 1movesleft8(&din, &readin);
      real_packet->hp = readin;
    }
  }
  if (BV_ISSET(fields, 13fuel = readin;
    }
  }
  if (BV_ISSET(fields, 14activity_count = readin;
    }
  }
  if (BV_ISSET(fields, 15unhappiness = readin;
    }
  }
  if (BV_ISSET(fields, 16)) {
    
    {
      int i;
    
      for (i = 0; i < O_MAXupkeep[i] = readin;
    }
      }
    }
  }
  if (BV_ISSET(fields, 17occupy = readin;
    }
  }
  if (BV_ISSET(fields, 18goto_dest_x = readin;
    }
  }
  if (BV_ISSET(fields, 19goto_dest_y = readin;
    }
  }
  if (BV_ISSET(fields, 20activity = readin;
    }
  }
  if (BV_ISSET(fields, 21activity_target = readin;
    }
  }
  if (BV_ISSET(fields, 22  real_packet->has_orders = BV_ISSET(fields, 23);
  if (BV_ISSET(fields, 24orders_length = readin;
    }
  }
  if (BV_ISSET(fields, 25orders_index = readin;
    }
  }
  real_packet->orders_repeat = BV_ISSET(fields, 26);
  real_packet->orders_vigilant = BV_ISSET(fields, 27);
  if (BV_ISSET(fields, 28)) {
    
    {
      int i;
    
      if(real_packet->orders_orders_length = MAX_LEN_ROUTE;
      }
29)) {
    
    {
      int i;
    
      if(real_packet->orders_orders_length = MAX_LEN_ROUTE;
      }
orders_dirs[i] = readin;
    }
      }
    }
  }
  if (BV_ISSET(fields, 30)) {
    
    {
      int i;
    
      if(real_packet->orders_orders_length = MAX_LEN_ROUTE;
      }
orders_activities[i] = readin;
    }
      }info_100(struct connection *pc, const struct packet_unit_info *packet)
{
  const struct packet_unit_info *real_packet = packet;
  packet_unit_info_100_fields fields;
  struct packet_unit_infoINFO];
  int different = 0;
  SEND_PACKET_START(PACKET_UNIT_INFO);

  if (!*hash) {
    *hash = hash_new(hash_packet_unit_info_100, cmp_packet_uniowner != real_packet->ownerdiffer = (old->homecity != real_packet->homecityai != real_packet->ai);
  if(differ) {different++;}
  if(packet->ai) {BV_SET(fields, 5);}

  differ = (old->paradropped != real_packet->paradropped);
  if(differ) {different++;}
  if(packet->paradroppeddone_moving != real_packet->done_moving);
  if(differ) {different++;}
  if(packet->done_moving) {BV_SET(fields, 8movesleft != real_packet->movesleft);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 1112);}

  differ = (old->fuel != real_packet->fuel);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 13);}

  differ = (old->activity™€ †  †  ƒ¯_€‚ ƒí?€9 ~’< rïd“ Sðw“ DƒÆ  xò= J‚¾{ XÇ ‹ Pö~‹ †š:€_ ‚2ƒ¢€E ^£{€G ‚£€D Z„‚z€„Y N„µ<¿ e…=¤ oŒ; ä|­ [·x€N ƒí?€) ~’< rïdŸ T‚Œsš O™1‡ XÇ ‡ Pö~‡ †š:€S ‚2ƒ¢€5 ^£{¿ ‚£€4 Z„‚z€„t M„µ=€M n…=© oŒ; ‚´ ƒ$Šc€h ƒí?€[ A±@© ŠS’<„ Qö}Ž †š:€h ‚2ƒ¢€Q g£{€D ‚£€P Z„‚z“ ©p… `ª|€ƒ M„µ=€I e…=® ‚Œ; _·t€g ƒí?€< ƒÂ  U‚»0 ƒ…‡‘ Pö~‹ †š9€b ‚2ƒ¢€I ^£{€I ‚£€H Z„‚zº …–K ND(real_packet);
}

static int send_packet_unit_paradrop_to_100(struct connection *pc, const struct packet_unit_paradrop_to *packet)
{
  const struct packet_unit_paradrop_to *real_packet = packet;
  packet_unit_paradrop_to_100_fields fields;
  struct packet_unit_paradrop_toUNIT_PARADROP_TO];
  int different = 0;
  SEND_PACKET_START(PACKET_UNIT_PARADROP_TO);

  if (!*hash) {
    *hash = hash_new(hash_packet_unit_paradrop_to_100, cmp_packet_unit_paradrop_tox != real_packet->xy != real_packet->yxyparadrop_toPARADROP_TOUNIT_PARADROP_TO] = variant;
}

struct packet_unit_paradrop_to *receive_packet_unit_paradrop_tounit_paradrop_to at the client.");
  }
  ensure_valid_variant_packet_unit_paradrop_to(pc);

  switch(pc->phs.variant[PACKET_UNIT_PARADROP_TO]) {
    case 100: return receive_packet_unit_paradrop_toparadrop_to(struct connection *pc, const struct packet_unit_paradrop_tounit_paradrop_to from the server.");
  }
  ensure_valid_variant_packet_unit_paradrop_to(pc);

  switch(pc->phs.variant[PACKET_UNIT_PARADROP_TO]) {
    case 100: return send_packet_unit_paradrop_tounit_paradrop_to(struct connection *pc, int unit_id, int x, int y)
{
  struct packet_unit_paradrop_to packet, *real_packet = &packet;

  real_packet->unit_id = unit_id;
  real_packet->x = x;
  real_packet->y = y;
  
  return send_packet_unit_paradrop_to(pc, real_packet);
}

#define hash_packet_unit_airlift_100 hash_const

#define cmp_packet_unit_airlift_100 cmp_const

BV_DEFINE(packet_unit_airlift_100_fields, 2);

static struct packet_unit_airlift *receive_packet_unit_airlift_100(struct connection *pc, enum packet_type type)
{
  packet_unit_airlift_100_fields fields;
  struct packet_unit_airlifunit_airlift *clone;
  RECEIVE_PACKET_START(packet_unit_airliftairlift_100, cmp_packet_unit_airlift16(&din, &readin);
      real_packet->city_idairlift_100(struct connection *pc, const struct packet_unit_airlift *packet)
{
  const struct packet_unit_airlift *real_packet = packet;
  packet_unit_airlift_100_fields fields;
  struct packet_unit_airliftUNIT_AIRLIFT];
  int different = 0;
  SEND_PACKET_START(PACKET_UNIT_AIRLIFT);

  if (!*hash) {
    *hash = hash_new(hash_packet_unit_airlift_100, cmp_packet_unit_airliftcity_id != real_packet->city_id16(&dout, real_packet->unicity_idairliftAIRLIFTUNIT_AIRLIFT] = variant;
}

struct packet_unit_airlift *receive_packet_unit_airliftunit_airlift at the client.");
  }
  ensure_valid_variant_packet_unit_airlift(pc);

  switch(pc->phs.variant[PACKET_UNIT_AIRLIFT]) {
    case 100: return receive_packet_unit_airliftairlift(struct connection *pc, const struct packet_unit_airliftunit_airlift from the server.");
  }
  ensure_valid_variant_packet_unit_airlift(pc);

  switch(pc->phs.variant[PACKET_UNIT_AIRLIFT]) {
    case 100: return send_packet_unit_airliftunit_airlift(struct connection *pc, int unit_id, int city_id)
{
  struct packet_unit_airlift packet, *real_packet = &packet;

  real_packet->unit_id = unit_id;
  real_packet->city_id = city_id;
  
  return send_packet_unit_airlift(pc, real_packet);
}

#define hash_packet_unit_diplomat_query_100 hash_const

#define cmp_packet_unit_diplomat_query_100 cmp_const

BV_DEFINE(packet_unit_diplomat_query_100_fields, 4);

static struct packet_unit_diplomat_query *receive_packet_unit_diplomat_query_100(struct connection *pc, enum packet_type type)
{
  packet_unit_diplomat_query_100_fields fields;
  struct packet_unit_diplomat_queryunit_diplomat_query *clone;
  RECEIVE_PACKET_START(packet_unit_diplomat_queryquery_100, cmp_packet_unit_diplomat_queryquery_100(struct connection *pc, const struct packet_unit_diplomat_query *packet)
{
  const struct packet_unit_diplomat_query *real_packet = packet;
  packet_unit_diplomat_query_100_fields fields;
  struct packet_unit_diplomat_queryUNIT_DIPLOMAT_QUERY];
  int different = 0;
  SEND_PACKET_START(PACKET_UNIT_DIPLOMAT_QUERY);query_100, cmp_packet_unit_diplomat_queryquerDIPLOMAT_QUERYUNIT_DIPLOMAT_QUERY] = variant;
}

struct packet_unit_diplomat_query *receive_packet_unit_diplomat_queryunit_diplomat_query at the client.");
  }
  ensure_valid_variant_packet_unit_diplomat_query(pc);

  switch(pc->phs.variant[PACKET_UNIT_DIPLOMAT_QUERY]) {
    case 100: return receive_packet_unit_diplomat_queryquery(struct connection *pc, const struct packet_unit_diplomat_queryunit_diplomat_query from the server.");
  }
  ensure_valid_variant_packet_unit_diplomat_query(pc);

  switch(pc->phs.variant[PACKET_UNIT_DIPLOMAT_QUERY]) {
    case 100: return send_packet_unit_diplomat_queryunit_diplomat_queryqueryquery(pc, real_packet);
}

#define hash_packet_unit_type_upgrade_100 hash_const

#define cmp_packet_unit_type_upgrade_100 cmp_const

BV_DEFINE(packet_unit_type_upgrade_100_fields, 1);

static struct packet_unit_type_upgrade *receive_packet_unit_type_upgrade_100(struct connection *pc, enum packet_type type)
{
  packet_unit_type_upgrade_100_fields fields;
  struct packet_unit_type_upgradeunit_type_upgrade *clone;
  RECEIVE_PACKET_START(packet_unit_type_upgradetype_upgrade_100, cmp_packet_unit_type_upgradetype_upgrade_100(struct connection *pc, const struct packet_unit_type_upgrade *packet)
{
  const struct packet_unit_type_upgrade *real_packet = packet;
  packet_unit_type_upgrade_100_fields fields;
  struct packet_unit_type_upgradeUNIT_TYPE_UPGRADE];
  int different = 0;
  SEND_PACKET_START(PACKET_UNIT_TYPE_UPGRADE);

  if (!*hash) {
    *hash = hash_new(hash_packet_unit_type_upgrade_100, cmp_packet_unit_type_upgradunit_type_upgradeTYPE_UPGRADUNIT_TYPE_UPGRADE] = variant;
}

struct packet_unit_type_upgrade *receive_packet_unit_type_upgradeunit_type_upgrade at the client.");
  }
  ensure_valid_variant_packet_unit_type_upgrade(pc);

  switch(pc->phs.variant[PACKET_UNIT_TYPE_UPGRADE]) {
    case 100: return receive_packet_unit_type_upgradetype_upgrade(struct connection *pc, const struct packet_unit_type_upgradeunit_type_upgrade from the server.");
  }
  ensure_valid_variant_packet_unit_type_upgrade(pc);

  switch(pc->phs.variant[PACKET_UNIT_TYPE_UPGRADE]) {
    case 100: return send_packet_unit_type_upgradeunit_type_upgrade(struct connection *pc, Unit_type_id typeŸ  †  †  „½M€ƒ6 Hº8€ †e€B R¿ ´ |À€b yÂ €t r„ñxŠ È,€s K‚—=­ F…û2€D …º € ‚Ü~€ƒ N„•v® D„–}µ `‚Æc— `‚Çh£ ,…‡Q¦ …ÔA€! K…Œx€W K„Õ<Š S„×;„ Pý?‰ ƒÀ}€J ‚1†Ž:€) Y„ß?¾ ‚Ÿ>€( […íyº D‚‰|‰ C„¬>€‚< R¿ €C `„ê:¨ uÂ  $„ì?€ b„ïr€f T‚¥>¢ [„î  b„ïr€Y Y‚³l¦ U…û#€] …º €, ‚Ü~€‚C …‚ €d …‚  ¸}¤ _†ˆ=€‚ bƒ¾8‰ Pý?Ž ƒÀ}€Y ‚1†Ž:€= Y„ß?€H ‚Ÿ>€< […íy€D D‚‰|€u SØm‰ N‡@€ K‰8‰ ƒÀ}€J ‚1†Ž:€) Y„ß?‰ ‚€t€( A”?¸ SØm‰ N‡@€ K‰8‰ ƒÀ}€J w†Ž:€d Y„ß?‰ \€t€` A”?¸ WØm… N‡@€ Q˜ ˆ ƒÀ|€D ‚7š;€) Y„ß?‰ ‚€t …“a‚jport_req(struct connection *pc, enum report_type type)
{
  struct packet_report_req packet, *real_packet = &packet;

  real_packet->type = type;
  
  return send_packet_report_req(pc, real_packet);
}

static unsigned int hash_packet_conn_info_100(const void *vkey, unsigned int num_buckets)
{
  const struct packet_conn_info *key = (const struct packet_conn_info *) vkey;

  return ((key->id) % num_buckets);
}

static int cmp_packet_connconn_info *key1 = (const struct packet_conn_info *) vkey1;
  const struct packet_conn_info *key2 = (const struct packet_conn_infoconn_info_100_fields, 8);

static struct packet_conn_info *receive_packet_conn_info_100(struct connection *pc, enum packet_type type)
{
  packet_conn_info_100_fields fields;
  struct packet_connconn_info *clone;
  RECEIVE_PACKET_START(packet_connid = readin;
  }


  if (!*hash) {
    *hash = hash_new(hash_packet_conn_info_100, cmp_packet_connid = real_packet->id;

    memset(real_packet, 0, sizeof(*real_packet));

    real_packet->id = id;
  }

  real_packet->used = BV_ISSET(fields, 0);
  real_packet->established = BV_ISSET(fields, 1);
  real_packet->observer = BV_ISSET(fields, 2);player_numaccess_level = readin;
    }
  }
  if (BV_ISSET(fields, 5)) {
    dio_get_string(&din, real_packet->username, sizeof(real_packet->username));
  }
  if (BV_ISSET(fields, 6)) {
    dio_get_string(&din, real_packet->addr, sizeof(real_packet->addrcapability, sizeof(real_packet->capability));conn_info_100(struct connection *pc, const struct packet_conn_info *packet)
{
  const struct packet_conn_info *real_packet = packet;
  packet_conn_info_100_fields fields;
  struct packet_conn_infoCONN_INFO];
  int different = 0;
  SEND_PACKET_START(PACKET_CONN_INFO);

  if (!*hash) {
    *hash = hash_new(hash_packet_conn_info_100, cmp_packet_connused != real_packet->used);
  if(differ) {different++;}
  if(packet->used) {BV_SET(fields, 0);}

  differ = (old->established != real_packet->established);
  if(differ) {different++;}
  if(packet->established) {BV_SET(fields, 1);}

  differ = (old->observer != real_packet->observer);
  if(differ) {different++;}
  if(packet->observer) {BV_SET(fields, 2);}

  differ = (old->player_num != real_packet->player_numold->access_level != real_packet->access_leveldiffer = (strcmp(old->username, real_packet->usernameaddr, real_packet->addrcapability, real_packet->capability  dio_put_uint8(&dout, real_packet->idif (BV_ISSET(fields, 3)) {
    dio_put_uint8(&dout, real_packet->player_num);
  }
  if (BV_ISSET(fields, 4)) {
    dio_put_uint8(&dout, real_packet->access_levelusername);
  }
  if (BV_ISSET(fields, 6)) {
    dio_put_string(&dout, real_packet->addrcapabilityconnCONN_INFOCONN_INFO] = variant;
}

struct packet_conn_info *receive_packet_conn_infoconn_info at the server.");
  }
  ensure_valid_variant_packet_conn_info(pc);

  switch(pc->phs.variant[PACKET_CONN_INFO]) {
    case 100: return receive_packet_conn_infoconn_info(struct connection *pc, const struct packet_conn_infoconn_info from the client.");
  }
  ensure_valid_variant_packet_conn_info(pc);

  switch(pc->phs.variant[PACKET_CONN_INFO]) {
    case 100: return send_packet_conn_infoconn_info(struct conn_list *dest, const struct packet_connconn_infoconn_ping_info_100 hash_const

#define cmp_packet_conn_ping_info_100 cmp_const

BV_DEFINE(packet_conn_ping_info_100_fields, 3);

static struct packet_conn_ping_info *receive_packet_conn_ping_info_100(struct connection *pc, enum packet_type type)
{
  packet_conn_ping_info_100_fields fields;
  struct packet_conn_pingconn_ping_info *clone;
  RECEIVE_PACKET_START(packet_conn_ping_infoconn_ping_info_100, cmp_packet_conn_pingconnections = readin;
    }
  }
  if (BV_ISSET(fields, 1)) {
    
    {
      int i;
    
      if(real_packet->connections > MAX_NUM_CONNECTIONconnections = MAX_NUM_CONNECTIONS;
      }
      for (i = 0; i < real_packet->connections; i++) {
    conn_id[i] = readin;
    }
      }connections > MAX_NUM_CONNECTIONconnections = MAX_NUM_CONNECTIONS;
      }
      for (i = 0; i < real_packet->connectionsing_time[i] = (float)(tmp) / 1000000.0conn_ping_info_100(struct connection *pc, const struct packet_conn_ping_info *packet)
{
  const struct packet_conn_ping_info *real_packet = packet;
  packet_conn_ping_info_100_fields fields;
  struct packet_conn_ping_infoCONN_PING_INFO];
  int different = 0;
  SEND_PACKET_START(PACKET_CONN_PING_INFO);

  if (!*hash) {
    *hash = hash_new(hash_packet_conn_ping_info_100, cmp_packet_conn_pingconnections != real_packet->connections);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 0);}


    {
      differ = (old->connections != real_packet->connections);
      if(!differ) {
        int i;
        for (i = 0; i < real_packet->connections; i++) {
          if (old->conn_id[i] != real_packet->conn_id[i]1);}


    {
      differ = (old->connections != real_packet->connections);
      if(!differ) {
        int i;
        for (i = 0; i < real_packet->connections; i++) {
          if (old->ping_time[i] != real_packet->ping_time[i]uint8(&dout, real_packet->connectionconnections; i++) {
        dio_put_uint8(&dout, real_packet->conn_id[i]);
      }
    } 
  }
  if (BV_ISSET(fields, 2)) {
  
    {
      int i;

      for (i = 0; i < real_packet->connections; i++) {
          dio_put_uint32(&dout, (int)(real_packet->ping_time[i] * 1000000)conn_pingCONN_PING_INFOCONN_PING_INFO] = variant;
}

struct packet_conn_ping_info *receive_packet_conn_ping_infoconn_ping_info at the server.");
  }
  ensure_valid_variant_packet_conn_ping_info(pc);

  switch(pc->phs.variant[PACKET_CONN_PING_INFO]) {
    case 100: return receive_packet_conn_ping_infoconn_ping_info(struct connection *pc, const struct packet_conn_ping_infoconn_ping_info from the client.");
  }
  ensure_valid_variant_packet_conn_ping_info(pc);

  switch(pc->phs.variant[PACKET_CONN_PING_INFO]) {
    case 100: return send_packet_conn_ping_infoconn_ping_info(struct conn_list *dest, const struct packet_conn_pingconn_ping_info(pconn, packet);
  } conn_list_iterate_end;
}

static struct packet_conn_ping *receive_packet_conn_pingconn_pingconn_ping_100(struct connection *pc)
{
  SEND_PACKET_START(PACKET_CONN_PING);
  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_conn_pingCONN_PINGCONN_PING] = variant;
}

struct packet_conn_ping *receive_packet_conn_pingconn_ping at the server.");
  }
  ensure_valid_variant_packet_conn_ping(pc);

  switch(pc->phs.variant[PACKET_CONN_PING]) {
    case 100: return receive_packet_conn_pingconn_pingconn_ping from the client.");
  }
  ensure_valid_variant_packet_conn_ping(pc);

  switch(pc->phs.variant[PACKET_CONN_PING]) {
    case 100: return send_packet_conn_pingstatic struct packet_conn_pong *receive_packet_conn_pongconn_pongconn_pong_100(struct connection *pc)
{
  SEND_PACKET_START(PACKET_CONN_PONG);
  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_conn_pongCONN_PONGCONN_PONG] = variant;
}

struct packet_conn_pong *receive_packet_conn_pong!pc->is_server) {
    freelog(LOG_ERROR, "Receiving packet_conn_pong at the client.");
  }
  ensure_valid_variant_packet_conn_pong(pc);

  switch(pc->phs.variant[PACKET_CONN_PONG]) {
    case 100: return receive_packet_conn_pongconn_pongpc->is_server) {
    freelog(LOG_ERROR, "Sending packet_conn_pong from the server.");
  }
  ensure_valid_variant_packet_conn_pong(pc);

  switch(pc->phs.variant[PACKET_CONN_PONG]) {
    case 100: return send_packet_conn_pongstatic struct packet_end_phase *receive_packet_end_phasephaseend_phase_100(struct connection *pc)
{
  SEND_PACKET_START(PACKET_END_PHASE);
  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_endEND_PHASEND_PHASE] = variant;
}

struct packet_end_phase *receive_packet_endend_phase at the server.");
  }
  ensure_valid_variant_packet_end_phase(pc);

  switch(pc->phs.variant[PACKET_END_PHASE]) {
    case 100: return receive_packet_end_phaseend_phase¥À †  †  ƒ~¿€f a…ú;€H ‚Û€D c‚Ó~€ C„À@€q Né€B \ê€F hƒÖ;· pƒ>€w r„ør „ùi› ^óu¸ ]‚ä6½ ]„ü0€I N® €@ b®}€M L”}¢ U°?€N õ7€U õ7” o8€z „Ðv€a E‚’~¯ ~†“9€„] T‚ó{€H T‚ôw¯ T‚õv¶ S‚öv€4 F‚²@€T O…“r€R X¸, m†—&± Á? 	‚œ2€@ Á@ 	‚œ2¼ Á@ l… €‚ K‚¶|› K‚þ>€„ U†q€X j†r€H j†r” mƒë@‡ S„à — Ž}€l ‚9ƒï€Q iƒ‰>€J ‚„è:€` j‚Ó~€" C„À@€f Fé€F Uê€H iƒÖ:³ pƒ> „Ç? Y™l ‚šF€[ N‚çu€x „Ð~€M ~†“9Ÿ B» $¿wª „Ÿ5 -… ¦ _Ñ7  nƒë? S…Åu Ž}€e ‚:ƒï~€Q a…ú;€N ‚Û€J c‚Ó~€‡ Gé~ …–>h(pc->phs.variant[PACKET_RULESET_GOVERNMENT]) {
    case 100: return receive_packet_ruleset_governmentgovernment(struct connection *pc, const struct packet_ruleset_governmentgovernment from the client.");
  }
  ensure_valid_variant_packet_ruleset_government(pc);

  switch(pc->phs.variant[PACKET_RULESET_GOVERNMENT]) {
    case 100: return send_packet_ruleset_governmentgovernment(struct conn_list *dest, const struct packet_ruleset_government *packet)
{
  conn_list_iterate(dest, pconn) {
    send_packet_ruleset_governmentruleset_terrain_control_100 hash_const

#define cmp_packet_ruleset_terrain_control_100 cmp_const

BV_DEFINE(packet_ruleset_terrain_control_100_fields, 15);

static struct packet_ruleset_terrain_control *receive_packet_ruleset_terrain_controlcontrol_100_fields fields;
  struct packet_ruleset_terrain_control_control *clone;
  RECEIVE_PACKET_START(packet_ruleset_terrain_controlterrain_control_100, cmp_packet_ruleset_terrain_controlmemset(real_packet, 0, sizeof(*real_packet));
  }

  real_packet->may_road = BV_ISSET(fields, 0);
  real_packet->may_irrigate = BV_ISSET(fields, 1);
  real_packet->may_mine = BV_ISSET(fields, 2);
  real_packet->may_transform = BV_ISSET(fields, 3);ocean_reclaim_requirement_pctland_channel_requirement_pcuint8(&din, &readin);
      real_packet->river_move_modesint16(&din, &readin);
      real_packet->river_defense_bonusuint16(&din, &readin);
      real_packet->river_trade_incr = readin;
    }
  }
  if (BV_ISSET(fields, 9)) {
    dio_get_string(&din, real_packet->river_help_text, sizeof(real_packet->river_help_text));sint16(&din, &readin);
      real_packet->fortress_defense_bonus16(&din, &readin);
      real_packet->road_superhighway_trade_bonus = readin;for (i = 0; i < O_MAX; i++) {
    rail_tile_bonus[i] = readin;
    }
      }
    }
  }
  if (BV_ISSET(fields, 13pollution_tile_penalty[i] = readin;
    }
      }
    }
  }
  if (BV_ISSET(fields, 14fallout_tile_penaltyterrain_control_100(struct connection *pc, const struct packet_ruleset_terrain_control *packet)
{
  const struct packet_ruleset_terrain_control *real_packet = packet;
  packet_ruleset_terrain_control_100_fields fields;
  struct packet_ruleset_terrainRULESET_TERRAIN_CONTROL];
  int different = 0;
  SEND_PACKET_START(PACKET_RULESET_TERRAIN_CONTROLcontrol_100, cmp_packet_ruleset_terrain_controlmay_road != real_packet->may_road);
  if(differ) {different++;}
  if(packet->may_road) {BV_SET(fields, 0);}

  differ = (old->may_irrigate != real_packet->may_irrigate);
  if(differ) {different++;}
  if(packet->may_irrigate) {BV_SET(fields, 1);}

  differ = (old->may_mine != real_packet->may_mine);
  if(differ) {different++;}
  if(packet->may_mine) {BV_SET(fields, 2);}

  differ = (old->may_transform != real_packet->may_transform);
  if(differ) {different++;}
  if(packet->may_transform) {BV_SET(fields, 3);}

  differ = (old->ocean_reclaim_requirement_pct != real_packet->ocean_reclaim_requirement_pcland_channel_requirement_pct != real_packet->land_channel_requirement_pcriver_move_mode != real_packet->river_move_modeiver_defense_bonus != real_packet->river_defense_bonusriver_trade_incr != real_packet->river_trade_incr);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 8);}

  differ = (strcmp(old->river_help_text, real_packet->river_help_9);}

  differ = (old->fortress_defense_bonus != real_packet->fortress_defense_bonusold->road_superhighway_trade_bonus != real_packet->road_superhighway_trade_bonus);rail_tile_bonus[i] != real_packet->rail_tile_bonu2pollution_tile_penalty[i] != real_packet->pollution_tile_penalty3fallout_tile_penalty[i] != real_packet->fallout_tile_penalty4/* field 0 is folded into the header */
  /* field 1 is folded into the header */
  /* field 2 is folded into the header */
  /* field 3 is folded into the header */
  if (BV_ISSET(fields, 4)) {
    dio_put_uint8(&dout, real_packet->ocean_reclaim_requirement_pcland_channel_requirement_pcriver_move_mode);
  }
  if (BV_ISSET(fields, 7)) {
    dio_put_sint16(&dout, real_packet->river_defense_bonus);
  }
  if (BV_ISSET(fields, 8)) {
    dio_put_uint16(&dout, real_packet->river_trade_incr);
  }
  if (BV_ISSET(fields, 9)) {
    dio_put_string(&dout, real_packet->river_help_text);
  }
  if (BV_ISSET(fields, 10)) {
    dio_put_sint16(&dout, real_packet->fortress_defense_bonus);
  }
  if (BV_ISSET(fields, 11)) {
    dio_put_uint16(&dout, real_packet->road_superhighway_trade_bonus);
  }
  if (BV_ISSET(fields, 116(&dout, real_packet->rail_tile_bonus[i]);
      }
    } 
  }
  if (BV_ISSET(fields, 13pollution_tile_penalty[i]);
      }
    } 
  }
  if (BV_ISSET(fields, 14fallout_tile_penaltyterrainRULESET_TERRAIN_CONTROLTERRAIN_CONTROL] = variant;
}

struct packet_ruleset_terrain_control *receive_packet_ruleset_terrain_controlterrain_control at the server.");
  }
  ensure_valid_variant_packet_ruleset_terrain_control(pc);

  switch(pc->phs.variant[PACKET_RULESET_TERRAIN_CONTROL]) {
    case 100: return receive_packet_ruleset_terrainterrain_control(struct connection *pc, const struct packet_ruleset_terrainruleset_terrain_control from the client.");
  }
  ensure_valid_variant_packet_ruleset_terrain_control(pc);

  switch(pc->phs.variant[PACKET_RULESET_TERRAIN_CONTROL]) {
    case 100: return send_packet_ruleset_terrain_control_control(struct conn_list *dest, const struct packet_ruleset_terrain_control *packet)
{
  conn_list_iterate(dest, pconn) {
    send_packet_ruleset_terrain_controlruleset_nation_groups_100 hash_const

#define cmp_packet_ruleset_nation_groups_100 cmp_const

BV_DEFINE(packet_ruleset_nation_groups_100_fields, 2);

static struct packet_ruleset_nation_groups *receive_packet_ruleset_nation_groupsnation_groups_100_fields fields;
  struct packet_ruleset_nation_groupsnation_groups *clone;
  RECEIVE_PACKET_START(packet_ruleset_nation_groupnation_groups_100, cmp_packet_ruleset_nation_groupsdio_get_string(&din, real_packet->groups[i], sizeof(real_packet->groups[i]));
      }
    }nation_groups_100(struct connection *pc, const struct packet_ruleset_nation_groups *packet)
{
  const struct packet_ruleset_nation_groups *real_packet = packet;
  packet_ruleset_nation_groups_100_fields fields;
  struct packet_ruleset_nation_groupsRULESET_NATION_GROUPS];
  int different = 0;
  SEND_PACKET_START(PACKET_RULESET_NATION_GROUPS);

  if (!*hash) {
    *hash = hash_new(hash_packet_ruleset_nation_groups_100, cmp_packet_ruleset_nation_groupsngroups != real_packet->ngroupsstrcmp(old->groups[i], real_packet->groups1ngroups);
  }
  if (BV_ISSET(fields, 1string(&dout, real_packet->groupnation_groupsNATION_GROUPSNATION_GROUPS] = variant;
}

struct packet_ruleset_nation_groups *receive_packet_ruleset_nation_groupnation_groups at the server.");
  }
  ensure_valid_variant_packet_ruleset_nation_groups(pc);

  switch(pc->phs.variant[PACKET_RULESET_NATION_GROUPS]) {
    case 100: return receive_packet_ruleset_nation_groupsnation_groups(struct connection *pc, const struct packet_ruleset_nation_groups_groups from the client.");
  }
  ensure_valid_variant_packet_ruleset_nation_groups(pc);

  switch(pc->phs.variant[PACKET_RULESET_NATION_GROUPS]) {
    case 100: return send_packet_ruleset_nation_groupsnation_groups(struct conn_list *dest, const struct packet_ruleset_nation_groups *packet)
{
  conn_list_iterate(dest, pconn) {
    send_packet_ruleset_nation_groups(pconn, packet);
  } conn_list_iterate_end;
}

static unsigned int hash_packet_ruleset_nation_100(const void *vkey, unsigned int num_buckets)
{
  const struct packet_ruleset_nation *key = (const struct packet_ruleset_nation *) vkey;

  return ((key->id) % num_buckets);
}

static int cmp_packet_ruleset_nation_100(const void *vkey1, const void *vkey2)
{
  const struct packet_ruleset_nation *key1 = (const struct packet_ruleset_nation *) vkey1;
  const struct packet_ruleset_nation *key2 = (const struct packet_ruleset_nation *) vkey2;
  int diff;

  diff = key1->id - key2->id;
  if (diff != 0) {
    return diff;
  }

  return 0;
}

BV_DEFINE(packet_ruleset_nation_100_fields, 18);

static struct packet_ruleset_nation *receive_packet_ruleset_natio«à ^ôr‚)¯€Š S €j ‚]€^ ‚2„Q€‚r F„ 9Š;€C \7€•? [ €_ ‚^€Q ‚9„R€‚^ F„ AŠ;€4 c8€  U&€g ‚^€] ‚9„R€‚v F„ AŠ;€D c8€Ÿf ^ €‰B ‚^€G ‚1„R€‚B F„ 9Š;€$ I8€‰x ‚]€O ‚2„Q€‚T F„ 9Š;€/ J7€…L ‚]€O ‚2„Q€‚T F„ 9Š;€/ J7€†/ ‚]€R ‚2„Q€‚Z F„ 9Š;€3 J7€†W ‚^€P w„R€ƒ F„  Š;€h I8d->scategory != real_packet->scategory);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 13);}

  if (different == 0 && !force_send_of_unchanged) {
    return 0;
  }

  DIO_BV_PUT(&dout, fields);

  if (BV_ISSET(fields, 0)) {
    dio_put_uint16(&dout, real_packet->id);
  }
  if (BV_ISSET(fields, 1)) {
    dio_put_string(&dout, real_packet->name);
  }
  if (BV_ISSET(fields, 2)) {
    dio_put_string(&dout, real_packet->short_help);
  }
  if (BV_ISSET(fields, 3)) {
    dio_put_string(&dout, real_packet->extra_help);
  }
  if (BV_ISSET(fields, 4)) {
    dio_put_uint8(&dout, real_packet->stype);
  }
  if (BV_ISSET(fields, 5)) {
    dio_put_uint8(&dout, real_packet->sclass);
  }
  /* field 6 is folded into the header */
  if (BV_ISSET(fields, 7)) {
    dio_put_sint32(&dout, real_packet->val);
  }
  if (BV_ISSET(fields, 8)) {
    dio_put_sint32(&dout, real_packet->default_val);
  }
  if (BV_ISSET(fields, 9)) {
    dio_put_sint32(&dout, real_packet->min);
  }
  if (BV_ISSET(fields, 10)) {
    dio_put_sint32(&dout, real_packet->max);
  }
  if (BV_ISSET(fields, 11)) {
    dio_put_string(&dout, real_packet->strval);
  }
  if (BV_ISSET(fields, 12)) {
    dio_put_string(&dout, real_packet->default_strval);
  }
  if (BV_ISSET(fields, 13)) {
    dio_put_uint8(&dout, real_packet->scategoryoptions_settable(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_OPTIONS_SETTABLOPTIONS_SETTABLE] = variant;
}

struct packet_options_settable *receive_packet_options_settabloptions_settable at the server.");
  }
  ensure_valid_variant_packet_options_settable(pc);

  switch(pc->phs.variant[PACKET_OPTIONS_SETTABLE]) {
    case 100: return receive_packet_options_settable_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_options_settable(struct connection *pc, const struct packet_options_settable *packetoptions_settable from the client.");
  }
  ensure_valid_variant_packet_options_settable(pc);

  switch(pc->phs.variant[PACKET_OPTIONS_SETTABLE]) {
    case 100: return send_packet_options_settabloptions_settable(struct conn_list *dest, const struct packet_options_settable *packet)
{
  conn_list_iterate(dest, pconn) {
    send_packet_options_settable(pconn, packet);
  } conn_list_iterate_end;
}

#define hash_packet_ruleset_effect_100 hash_const

#define cmp_packet_ruleset_effect_100 cmp_const

BV_DEFINE(packet_ruleset_effect_100_fields, 2);

static struct packet_ruleset_effect *receive_packet_ruleset_effect_100(struct connection *pc, enum packet_type type)
{
  packet_ruleset_effect_100_fields fields;
  struct packet_ruleset_effect *old;
  struct hash_table **hash = &pc->phs.received[type];
  struct packet_ruleset_effect *clone;
  RECEIVE_PACKET_START(packet_ruleset_effect, real_packet);

  DIO_BV_GET(&din, fields);


  if (!*hash) {
    *hash = hash_new(hash_packet_ruleset_effect_100, cmp_packet_ruleset_effect_100);
  }
  old = hash_delete_entry(*hash, real_packet);

  if (old) {
    *real_packet = *old;
  } else {
    memset(real_packet, 0, sizeof(*real_packet));
  }

  if (BV_ISSET(fields, 0)) {
    {
      int readin;
    
      dio_get_uint8(&din, &readin);
      real_packet->effect_type = readin;
    }
  }
  if (BV_ISSET(fields, 1)) {
    {
      int readin;
    
      dio_get_sint32(&din, &readin);
      real_packet->effect_value = readin;
    }
  }

  clone = fc_malloc(sizeof(*clone));
  *clone = *real_packet;
  if (old) {
    free(old);
  }
  hash_insert(*hash, clone, clone);

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_ruleset_effect_100(struct connection *pc, const struct packet_ruleset_effect *packet)
{
  const struct packet_ruleset_effect *real_packet = packet;
  packet_ruleset_effect_100_fields fields;
  struct packet_ruleset_effect *old, *clone;
  bool differ, old_from_hash, force_send_of_unchanged = TRUE;
  struct hash_table **hash = &pc->phs.sent[PACKET_RULESET_EFFECT];
  int different = 0;
  SEND_PACKET_START(PACKET_RULESET_EFFECT);

  if (!*hash) {
    *hash = hash_new(hash_packet_ruleset_effect_100, cmp_packet_ruleset_effect_100);
  }
  BV_CLR_ALL(fields);

  old = hash_lookup_data(*hash, real_packet);
  old_from_hash = (old != NULL);
  if (!old) {
    old = fc_malloc(sizeof(*old));
    memset(old, 0, sizeof(*old));
    force_send_of_unchanged = TRUE;
  }

  differ = (old->effect_type != real_packet->effect_type);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 0);}

  differ = (old->effect_value != real_packet->effect_value);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 1);}

  if (different == 0 && !force_send_of_unchanged) {
    return 0;
  }

  DIO_BV_PUT(&dout, fields);

  if (BV_ISSET(fields, 0)) {
    dio_put_uint8(&dout, real_packet->effect_type);
  }
  if (BV_ISSET(fields, 1)) {
    dio_put_sint32(&dout, real_packet->effect_valueeffect(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_RULESET_EFFECTEFFECT] = variant;
}

struct packet_ruleset_effect *receive_packet_ruleset_effecteffect at the server.");
  }
  ensure_valid_variant_packet_ruleset_effect(pc);

  switch(pc->phs.variant[PACKET_RULESET_EFFECT]) {
    case 100: return receive_packet_ruleset_effect_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_ruleset_effect(struct connection *pc, const struct packet_ruleset_effect *packeteffect from the client.");
  }
  ensure_valid_variant_packet_ruleset_effect(pc);

  switch(pc->phs.variant[PACKET_RULESET_EFFECT]) {
    case 100: return send_packet_ruleset_effecteffect(struct conn_list *dest, const struct packet_ruleset_effect *packet)
{
  conn_list_iterate(dest, pconn) {
    send_packet_ruleset_effect(pconn, packet);
  } conn_list_iterate_end;
}

#define hash_packet_ruleset_effect_req_100 hash_const

#define cmp_packet_ruleset_effect_req_100 cmp_const

BV_DEFINE(packet_ruleset_effect_req_100_fields, 7);

static struct packet_ruleset_effect_req *receive_packet_ruleset_effect_req_100(struct connection *pc, enum packet_type type)
{
  packet_ruleset_effect_req_100_fields fields;
  struct packet_ruleset_effect_req *old;
  struct hash_table **hash = &pc->phs.received[type];
  struct packet_ruleset_effect_req *clone;
  RECEIVE_PACKET_START(packet_ruleset_effect_req, real_packet);

  DIO_BV_GET(&din, fields);


  if (!*hash) {
    *hash = hash_new(hash_packet_ruleset_effect_req_100, cmp_packet_ruleset_effect_req_100);
  }
  old = hash_delete_entry(*hash, real_packet);

  if (old) {
    *real_packet = *old;
  } else {
    memset(real_packet, 0, sizeof(*real_packet));
  }

  if (BV_ISSET(fields, 0)) {
    {
      int readin;
    
      dio_get_uint32(&din, &readin);
      real_packet->effect_id = readin;
    }
  }
  real_packet->neg = BV_ISSET(fields, 1);
  if (BV_ISSET(fields, 2)) {
    {
      int readin;
    
      dio_get_uint8(&din, &readin);
      real_packet->source_type = readin;
    }
  }
  if (BV_ISSET(fields, 3)) {
    {
      int readin;
    
      dio_get_sint32(&din, &readin);
      real_packet->source_value = readin;
    }
  }
  if (BV_ISSET(fields, 4)) {
    {
      int readin;
    
      dio_get_uint8(&din, &readin);
      real_packet->range = readin;
    }
  }
  real_packet->survives = BV_ISSET(fields, 5);
  real_packet->negated = BV_ISSET(fields, 6);

  clone = fc_malloc(sizeof(*clone));
  *clone = *real_packet;
  if (old) {
    free(old);
  }
  hash_insert(*hash, clone, clone);

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_ruleset_effect_req_100(struct connection *pc, const struct packet_ruleset_effect_req *packet)
{
  const struct packet_ruleset_effect_req *real_packet = packet;
  packet_ruleset_effect_req_100_fields fields;
  struct packet_ruleset_effect_req *old, *clone;
  bool differ, old_from_hash, force_send_of_unchanged = TRUE;
  struct hash_table **hash = &pc->phs.sent[PACKET_RULESET_EFFECT_REQ];
  int different = 0;
  SEND_PACKET_START(PACKET_RULESET_EFFECT_REQ);

  if (!*hash) {
    *hash = hash_new(hash_packet_ruleset_effect_req_100, cmp_packet_ruleset_effect_req_100);
  }
  BV_CLR_ALL(fields);

  old = hash_lookup_data(*hash, real_packet);
  old_from_hash = (old != NULL);
  if (!old) {
    old = fc_malloc(sizeof(*old));
    memset(old, 0, sizeof(*old));
    force_send_of_unchanged = TRUE;
  }

  differ = (old->effect_id != real_packet->effect_id);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 0);}

  differ = (old->neg != real_packet->neg);
  if(differ) {different++;}
  if(packet->neg) {BV_SET(fields, 1);}

  differ = (old->source_type != real_packet->source_type);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 2);}

  differ = (old->source_value != real_packet->source_value);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 3);}

  differ = (old->range != real_packet->range);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 4);}

  differ = (old->survives != real_packet->survives);
  if(differ) {different++;}
  if(packet->survives) {BV_SET(fields, 5);}

  differ = (old->negated != real_packet->negated);
  if(differ) {different++;}
  if(packet->negated) {BV_SET(fields, 6);}

  if (different == 0 && !force_send_of_unchanged) {
    return 0;
  }

  DIO_BV_PUT(&dout, fields);

  if (BV_ISSET(fields, 0)) {
    dio_put_uint32(&dout, real_packet->effect_id);
  }
  /* field 1 is folded into the header */
  if (BV_ISSET(fields, 2)) {
    dio_put_uint8(&dout, real_packet->source_type);
  }
  if (BV_ISSET(fields, 3)) {
    dio_put_sint32(&dout, real_packet->source_value);
  }
  if (BV_ISSET(fields, 4)) {
    dio_put_uint8(&dout, real_packet->range);
  }
  /* field 5 is folded into the header */
  /* field 6 is folded into the header */effect_req(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_RULESET_EFFECT_REQEFFECT_REQ] = variant;
}

struct packet_ruleset_effect_req *receive_packet_ruleset_effect_reqeffect_req at the server.");
  }
  ensure_valid_variant_packet_ruleset_effect_req(pc);

  switch(pc->phs.variant[PACKET_RULESET_EFFECT_REQ]) {
    case 100: return receive_packet_ruleset_effect_req_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_ruleset_effect_req(struct connection *pc, const struct packet_ruleset_effect_req *packeteffect_req from the client.");
  }
  ensure_valid_variant_packet_ruleset_effect_req(pc);

  switch(pc->phs.variant[PACKET_RULESET_EFFECT_REQ]) {
    case 100: return send_packet_ruleset_effect_reqeffect_req(struct conn_list *dest, const struct packet_ruleset_effect_req *packet)
{
  conn_list_iterate(dest, pconn) {
    send_packet_ruleset_effect_req(pconn, packet);
  } conn_list_iterate_end;
}

#define hash_packet_ruleset_resource_100 hash_const

#define cmp_packet_ruleset_resource_100 cmp_const

BV_DEFINE(packet_ruleset_resource_100_fields, 5);

static struct packet_ruleset_resource *receive_packet_ruleset_resource_100(struct connection *pc, enum packet_type type)
{
  packet_ruleset_resource_100_fields fields;
  struct packet_ruleset_resource *old;
  struct hash_table **hash = &pc->phs.received[type];
  struct packet_ruleset_resource *clone;
  RECEIVE_PACKET_START(packet_ruleset_resource, real_packet);

  DIO_BV_GET(&din, fields);


  if (!*hash) {
    *hash = hash_new(hash_packet_ruleset_resource_100, cmp_packet_ruleset_resource_100);
  }
  old = hash_delete_entry(*hash, real_packet);

  if (old) {
    *real_packet = *old;
  } else {
    memset(real_packet, 0, sizeof(*real_packet));
  }

  if (BV_ISSET(fields, 0)) {
    {
      int readin;
    
      dio_get_sint8(&din, &readin);
      real_packet->id = readin;
    }
  }
  if (BV_ISSET(fields, 1)) {
    dio_get_string(&din, real_packet->name_orig, sizeof(real_packet->name_orig));
  }
  if (BV_ISSET(fields, 2)) {
    
    {
      int i;
    
      for (i = 0; i < O_MAX; i++) {
        {
      int readin;
    
      dio_get_uint8(&din, &readin);
      real_packet->output[i] = readin;
    }
      }
    }
  }
  if (BV_ISSET(fields, 3)) {
    dio_get_string(&din, real_packet->graphic_str, sizeof(real_packet->graphic_str));
  }
  if (BV_ISSET(fields, 4)) {
    dio_get_string(&din, real_packet->graphic_alt, sizeof(real_packet->graphic_alt));
  }

  clone = fc_malloc(sizeof(*clone));
  *clone = *real_packet;
  if (old) {
    free(old);
  }
  hash_insert(*hash, clone, clone);

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_ruleset_resource_100(struct connection *pc, const struct packet_ruleset_resource *packet)
{
  const struct packet_ruleset_resource *real_packet = packet;
  packet_ruleset_resource_100_fields fields;
  struct packet_ruleset_resource *old, *clone;
  bool differ, old_from_hash, force_send_of_unchanged = TRUE;
  struct hash_table **hash = &pc->phs.sent[PACKET_RULESET_RESOURCE];
  int different = 0;
  SEND_PACKET_START(PACKET_RULESET_RESOURCE);

  if (!*hash) {
    *hash = hash_new(hash_packet_ruleset_resource_100, cmp_packet_ruleset_resource_100);
  }
  BV_CLR_ALL(fields);

  old = hash_lookup_data(*hash, real_packet);
  old_from_hash = (old != NULL);
  if (!old) {
    old = fc_malloc(sizeof(*old));
    memset(old, 0, sizeof(*old));
    force_send_of_unchanged = TRUE;
  }

  differ = (old->id != real_packet->id);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 0);}

  differ = (strcmp(old->name_orig, real_packet->name_orig) != 0);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 1);}


    {
      differ = (O_MAX != O_MAX);
      if(!differ) {
        int i;
        for (i = 0; i < O_MAX; i++) {
          if (old->output[i] != real_packet->output[i]) {
            differ = TRUE;
            break;
          }
        }
      }
    }
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 2);}

  differ = (strcmp(old->graphic_str, real_packet->graphic_str) != 0);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 3);}

  differ = (strcmp(old->graphic_alt, real_packet->graphic_alt) != 0);
  if(differ) {different++;}
  if(differ) {BV_SET(fields, 4);}

  if (different == 0 && !force_send_of_unchanged) {
    return 0;
  }

  DIO_BV_PUT(&dout, fields);

  if (BV_ISSET(fields, 0)) {
    dio_put_sint8(&dout, real_packet->id);
  }
  if (BV_ISSET(fields, 1)) {
    dio_put_string(&dout, real_packet->name_orig);
  }
  if (BV_ISSET(fields, 2)) {
  
    {
      int i;

      for (i = 0; i < O_MAX; i++) {
        dio_put_uint8(&dout, real_packet->output[i]);
      }
    } 
  }
  if (BV_ISSET(fields, 3)) {
    dio_put_string(&dout, real_packet->graphic_str);
  }
  if (BV_ISSET(fields, 4)) {
    dio_put_stringstatic struct packet_vote_new *receive_packet_vote_new_100(struct connection *pc, enum packet_type type)
{
  RECEIVE_PACKET_START(packet_vote_new, real_packet);
  {
    int readin;
  
    dio_get_uint32(&din, &readin);
    real_packet->vote_no = readin;
  }
  dio_get_string(&din, real_packet->user, sizeof(real_packet->user));
  dio_get_string(&din, real_packet->desc, sizeof(real_packet->desc));
  {
    int readin;
  
    dio_get_uint8(&din, &readin);
    real_packet->percent_required = readin;
  }
  {
    int readin;
  
    dio_get_uint32(&din, &readin);
    real_packet->flags = readin;
  }

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_vote_new_100(struct connection *pc, const struct packet_vote_new *packet)
{
  const struct packet_vote_new *real_packet = packet;
  SEND_PACKET_START(PACKET_VOTE_NEW);

  dio_put_uint32(&dout, real_packet->vote_no);
  dio_put_string(&dout, real_packet->user);
  dio_put_string(&dout, real_packet->desc);
  dio_put_uint8(&dout, real_packet->percent_required);
  dio_put_uint32(&dout, real_packet->flags);

  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_vote_new(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_VOTE_NEWVOTE_NEW] = variant;
}

struct packet_vote_new *receive_packet_vote_newvote_new at the server.");
  }
  ensure_valid_variant_packet_vote_new(pc);

  switch(pc->phs.variant[PACKET_VOTE_NEW]) {
    case 100: return receive_packet_vote_new_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_vote_new(struct connection *pc, const struct packet_vote_new *packetvote_new from the client.");
  }
  ensure_valid_variant_packet_vote_new(pc);

  switch(pc->phs.variant[PACKET_VOTE_NEW]) {
    case 100: return send_packet_vote_newstatic struct packet_vote_update *receive_packet_vote_update_100(struct connection *pc, enum packet_type type)
{
  RECEIVE_PACKET_START(packet_vote_update, real_packet);
  {
    int readin;
  
    dio_get_uint32(&din, &readin);
    real_packet->vote_no = readin;
  }
  {
    int readin;
  
    dio_get_uint8(&din, &readin);
    real_packet->yes = readin;
  }
  {
    int readin;
  
    dio_get_uint8(&din, &readin);
    real_packet->no = readin;
  }
  {
    int readin;
  
    dio_get_uint8(&din, &readin);
    real_packet->abstain = readin;
  }
  {
    int readin;
  
    dio_get_uint8(&din, &readin);
    real_packet->num_voters = readin;
  }

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_vote_update_100(struct connection *pc, const struct packet_vote_update *packet)
{
  const struct packet_vote_update *real_packet = packet;
  SEND_PACKET_START(PACKET_VOTE_UPDATE);

  dio_put_uint32(&dout, real_packet->vote_no);
  dio_put_uint8(&dout, real_packet->yes);
  dio_put_uint8(&dout, real_packet->no);
  dio_put_uint8(&dout, real_packet->abstain);
  dio_put_uint8(&dout, real_packet->num_voters);

  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_vote_update(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_VOTE_UPDATVOTE_UPDATE] = variant;
}

struct packet_vote_update *receive_packet_vote_updatvote_update at the server.");
  }
  ensure_valid_variant_packet_vote_update(pc);

  switch(pc->phs.variant[PACKET_VOTE_UPDATE]) {
    case 100: return receive_packet_vote_update_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_vote_update(struct connection *pc, const struct packet_vote_update *packetvote_update from the client.");
  }
  ensure_valid_variant_packet_vote_update(pc);

  switch(pc->phs.variant[PACKET_VOTE_UPDATE]) {
    case 100: return send_packet_vote_updatstatic struct packet_vote_remove *receive_packet_vote_remove_100(struct connection *pc, enum packet_type type)
{
  RECEIVE_PACKET_START(packet_vote_remove, real_packet);
  {
    int readin;
  
    dio_get_uint32(&din, &readin);
    real_packet->vote_no = readin;
  }

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_vote_remove_100(struct connection *pc, const struct packet_vote_remove *packet)
{
  const struct packet_vote_remove *real_packet = packet;
  SEND_PACKET_START(PACKET_VOTE_REMOVE);

  dio_put_uint32(&dout, real_packet->vote_no);

  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_vote_remove(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_VOTE_REMOVVOTE_REMOVE] = variant;
}

struct packet_vote_remove *receive_packet_vote_removvote_remove at the server.");
  }
  ensure_valid_variant_packet_vote_remove(pc);

  switch(pc->phs.variant[PACKET_VOTE_REMOVE]) {
    case 100: return receive_packet_vote_remove_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_vote_remove(struct connection *pc, const struct packet_vote_remove *packetvote_remove from the client.");
  }
  ensure_valid_variant_packet_vote_remove(pc);

  switch(pc->phs.variant[PACKET_VOTE_REMOVE]) {
    case 100: return send_packet_vote_removstatic struct packet_vote_resolve *receive_packet_vote_resolve_100(struct connection *pc, enum packet_type type)
{
  RECEIVE_PACKET_START(packet_vote_resolve, real_packet);
  {
    int readin;
  
    dio_get_uint32(&din, &readin);
    real_packet->vote_no = readin;
  }
  dio_get_bool8(&din, &real_packet->passed);

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_vote_resolve_100(struct connection *pc, const struct packet_vote_resolve *packet)
{
  const struct packet_vote_resolve *real_packet = packet;
  SEND_PACKET_START(PACKET_VOTE_RESOLVE);

  dio_put_uint32(&dout, real_packet->vote_no);
  dio_put_bool8(&dout, real_packet->passed);

  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_vote_resolve(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_VOTE_RESOLVVOTE_RESOLVE] = variant;
}

struct packet_vote_resolve *receive_packet_vote_resolvvote_resolve at the server.");
  }
  ensure_valid_variant_packet_vote_resolve(pc);

  switch(pc->phs.variant[PACKET_VOTE_RESOLVE]) {
    case 100: return receive_packet_vote_resolve_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_vote_resolve(struct connection *pc, const struct packet_vote_resolve *packetvote_resolve from the client.");
  }
  ensure_valid_variant_packet_vote_resolve(pc);

  switch(pc->phs.variant[PACKET_VOTE_RESOLVE]) {
    case 100: return send_packet_vote_resolvstatic struct packet_vote_submit *receive_packet_vote_submit_100(struct connection *pc, enum packet_type type)
{
  RECEIVE_PACKET_START(packet_vote_submit, real_packet);
  {
    int readin;
  
    dio_get_uint32(&din, &readin);
    real_packet->vote_no = readin;
  }
  {
    int readin;
  
    dio_get_sint8(&din, &readin);
    real_packet->value = readin;
  }

  RECEIVE_PACKET_END(real_packet);
}

static int send_packet_vote_submit_100(struct connection *pc, const struct packet_vote_submit *packet)
{
  const struct packet_vote_submit *real_packet = packet;
  SEND_PACKET_START(PACKET_VOTE_SUBMIT);

  dio_put_uint32(&dout, real_packet->vote_no);
  dio_put_sint8(&dout, real_packet->value);

  SEND_PACKET_END;
}

static void ensure_valid_variant_packet_vote_submit(struct connection *pc)
{
  int variant = -1;

  if(pc->phs.variant[PACKET_VOTE_SUBMITVOTE_SUBMIT] = variant;
}

struct packet_vote_submit *receive_packet_vote_submit!pc->is_server) {
    freelog(LOG_ERROR, "Receiving packet_vote_submit at the client.");
  }
  ensure_valid_variant_packet_vote_submit(pc);

  switch(pc->phs.variant[PACKET_VOTE_SUBMIT]) {
    case 100: return receive_packet_vote_submit_100(pc, type);
    default: die("unknown variant"); return NULL;
  }
}

int send_packet_vote_submit(struct connection *pc, const struct packet_vote_submit *packetpc->is_server) {
    freelog(LOG_ERROR, "Sending packet_vote_submit from the server.");
  }
  ensure_valid_variant_packet_vote_submit(pc);

  switch(pc->phs.variant[PACKET_VOTE_SUBMIT]) {
    case 100: return send_packet_vote_submitENDREP
DELTA 14678 239 94
SVN  ƒßƒêQCˆh ¢V €ƒ šg¢P€p ‚ A½5¯ @‚¦ €| A‚¥€| G‚¥y€ B‚¥~€ @‚¦ €B !ƒÝjstruct packet_vote_new {
  int vote_no;
  char user[MAX_LEN_NAME];
  char desc[512];
  int percent_required;
  int flags;
};

struct packet_vote_update {
  int vote_no;
  int yes;
  int no;
  int abstain;
  int num_voters;
};

struct packet_vote_remove {
  int vote_no;
};

struct packet_vote_resolve {
  int vote_no;
  bool passed;
};

struct packet_vote_submit {
  int vote_no;
  int value  PACKET_VOTE_NEW = 145,
  PACKET_VOTE_UPDATE,
  PACKET_VOTE_REMOVE,
  PACKET_VOTE_RESOLVE,
  PACKET_VOTE_SUBMITstruct packet_vote_new *receive_packet_vote_newvote_new(struct connection *pc, const struct packet_vote_new *packet);

struct packet_vote_update *receive_packet_vote_updatvote_update(struct connection *pc, const struct packet_vote_update *packet);

struct packet_vote_remove *receive_packet_votevote_remove(struct connection *pc, const struct packet_vote_remove *packet);

struct packet_vote_resolve *receive_packet_vote_resolvote_resolve(struct connection *pc, const struct packet_vote_resolve *packet);

struct packet_vote_submit *receive_packet_vote_submitvote_submit(struct connection *pc, const struct packet_vote_submitENDREP
DELTA 7142 3046 2370
SVN  Ò,Õ^O ƒ` ­ ‚6ƒ\‰ ‚…]€ ;‡O‡ /˜ -šL€i ‚œ'€c ‹[Ÿi€* M«€‚{  ±_€B …k²c€‚4 ‚n»a€ ’4¿W€‚8Ñtfdef HAVE_CONFIG_H
#include <config.h>
#endifplayer_noPLAYER_READY:
    handle_player_ready(pplayer,
      ((struct packet_player_ready *)packet)->player_no,
      ((struct packet_player_ready *)packet)->is_readyoptionsPHASE_DONE:
    handle_player_phase_done(pplayer,
      ((struct packet_player_phase_done *)packet)->turnCHANGE_GOVERNMENT:
    handle_player_change_government(pplayer,
      ((struct packet_player_changeBATTLEGROUP:
    handle_unit_battlegroup(pplayer,
      ((struct packet_unit_battlegroup *)packet)->unit_id,
      ((struct packet_unit_battlegroup *)packet)->battlegroupORDERS:
    handle_unit_orders(pplayer, packet);
    return TRUE;

  case PACKET_UNIT_AUTOSETTLERS:
    handle_unit_autosettlers(pplayer,
      ((struct packet_unit_autosettlers *)packet)->unit_id);
    return TRUE;

  case PACKET_UNIT_LOAD:
    handle_unit_load(pplayer,
      ((struct packet_unit_load *)packet)->cargo_id,
      ((struct packet_unit_load *)packet)->transportercargo_id,
      ((struct packet_unit_unload *)packet)->transporterDIPLOMAT_QUERY:
    handle_unit_diplomat_query(pconn,
      ((struct packet_unit_diplomat_query *)packet)->diplomat_id,
      ((struct packet_unit_diplomat_query *)packet)->target_id,
      ((struct packet_unit_diplomat_query *)packet)->value,
      ((struct packet_unit_diplomat_query *)packet)->action_typetarget_id,
      ((struct packet_unit_diplomat_action *)packet)->value,
      ((struct packet_unit_diplomat_action *)packet)->action_typcase PACKET_SINGLE_WANT_HACK_REQ:
    handle_single_want_hack_req(pconn, packet);
    return TRUE;

  case PACKET_VOTE_SUBMIT:
    handle_vote_submit(pconn,
      ((struct packet_vote_submit *)packet)->vote_no,
      ((struct packet_vote_submit *)packet)->valueENDREP
DELTA 13744 42543 375
SVN  ¨?©e ¨" €evoid handle_vote_submit(struct connection *pc, int vote_no, int value);

#endif /* FC__HAND_GEN_H */
ENDREP
id: 2fo.59e.r15673/64573
type: file
pred: 2fo.59e.r13744/48778
count: 16
text: 15673 62549 1849 10904 a9391223e76d6e664604817f4f87c178
props: 10753 3824 111 0 d4514082fc7e52be026d3360dec4dcb0
cpath: /branches/S2_1/server/hand_gen.c
copyroot: 11448 /branches/S2_1

id: 2f9.59e.r15673/64837
type: file
pred: 2f9.59e.r13744/49300
count: 19
text: 15673 64426 118 5255 6b2b507e2ea141140dc8c220434ac03f
props: 10753 4179 111 0 2a5912525b098cb46a1301ee940f7617
cpath: /branches/S2_1/server/hand_gen.h
copyroot: 11448 /branches/S2_1

PLAIN
K 11
Makefile.am
V 24
file 5q.59e.r15671/13453
K 9
airgoto.c
V 23
file 160.59e.r12202/274
K 9
airgoto.h
V 23
file 161.59e.r12202/528
K 6
auth.c
V 22
file 39c.59e.r15361/58
K 6
auth.h
V 25
file 39d.59e.r13514/10767
K 11
barbarian.c
V 23
file lw.59e.r14981/2668
K 11
barbarian.h
V 21
file lx.0.r10733/9671
K 10
cityhand.c
V 24
file 10.59e.r15267/27306
K 10
cityhand.h
V 22
file 4f.0.r10360/45679
K 11
citytools.c
V 23
file 4g.59e.r14946/6172
K 11
citytools.h
V 23
file 4h.59e.r14724/7206
K 10
cityturn.c
V 23
file 4i.59e.r14990/2455
K 10
cityturn.h
V 20
file 4j.0.r8119/8321
K 11
civserver.c
V 23
file 4k.59e.r15614/1921
K 11
civserver.h
V 21
file 4l.0.r2805/33121
K 10
commands.c
V 25
file 2ly.59e.r15672/21786
K 10
commands.h
V 25
file 2lz.59e.r15672/22048
K 13
connecthand.c
V 25
file 2dw.59e.r15672/22568
K 13
connecthand.h
V 24
file 2dx.59e.r15646/5359
K 9
console.c
V 21
file dd.0.r11144/6041
K 9
console.h
V 23
file de.59e.r11698/7135
K 10
diplhand.c
V 26
file 4m.59e.r14210/2228805
K 10
diplhand.h
V 23
file 4n.59e.r13422/2662
K 11
diplomats.c
V 23
file vz.59e.r15484/8663
K 11
diplomats.h
V 24
file w0.59e.r13744/49823
K 10
gamehand.c
V 21
file 4o.59e.r15658/91
K 10
gamehand.h
V 23
file 4p.59e.r13723/2527
K 9
generator
V 24
dir 2me.59e.r15385/24293
K 11
ggzserver.c
V 25
file 39a.59e.r15001/33940
K 11
ggzserver.h
V 25
file 39b.59e.r15001/34202
K 10
gotohand.c
V 22
file 11.59e.r14973/467
K 10
gotohand.h
V 22
file 7r.59e.r14973/728
K 10
hand_gen.c
V 25
file 2fo.59e.r15673/64573
K 10
hand_gen.h
V 25
file 2f9.59e.r15673/64837
K 10
handchat.c
V 26
file 4q.59e.r14210/2225075
K 10
handchat.h
V 22
file dj.0.r7100/189089
K 9
maphand.c
V 23
file 13.59e.r14946/6429
K 9
maphand.h
V 25
file 14.59e.r13925/175227
K 6
meta.c
V 23
file 4s.59e.r15614/2692
K 6
meta.h
V 23
file 4t.59e.r15617/1238
K 9
plrhand.c
V 24
file 4u.59e.r15672/23558
K 9
plrhand.h
V 24
file 4v.59e.r15672/23819
K 8
report.c
V 22
file vi.59e.r15632/816
K 8
report.h
V 23
file vj.59e.r15632/1070
K 9
ruleset.c
V 23
file 8w.59e.r14978/2372
K 9
ruleset.h
V 23
file 8x.59e.r14152/9709
K 13
sanitycheck.c
V 23
file wi.59e.r14667/2232
K 13
sanitycheck.h
V 24
file wj.59e.r14267/56478
K 10
savegame.c
V 22
file vl.59e.r15480/195
K 10
savegame.h
V 21
file vm.0.r10073/2584
K 7
score.c
V 23
file 2eg.59e.r15630/664
K 7
score.h
V 22
file 2eh.0.r11430/3487
K 9
scripting
V 24
dir 31x.59e.r15267/28824
K 8
sernet.c
V 24
file 15.59e.r15672/22833
K 8
sernet.h
V 24
file 4y.59e.r14122/42841
K 10
settings.c
V 24
file 2m0.59e.r15471/1686
K 10
settings.h
V 24
file 2m1.59e.r15274/4375
K 10
settlers.c
V 24
file 7s.59e.r14267/55945
K 10
settlers.h
V 19
file 7t.0.r9484/937
K 11
spacerace.c
V 26
file 9a.59e.r14210/2228005
K 11
spacerace.h
V 21
file 9b.0.r11338/1129
K 10
srv_main.c
V 24
file vg.59e.r15672/22306
K 10
srv_main.h
V 23
file vh.59e.r15614/2436
K 11
stdinhand.c
V 24
file 4z.59e.r15672/23294
K 11
stdinhand.h
V 24
file 50.59e.r15001/34723
K 11
techtools.c
V 24
file 33n.59e.r14981/2926
K 11
techtools.h
V 24
file 33o.59e.r14981/3190
K 10
unithand.c
V 22
file 18.59e.r15669/431
K 10
unithand.h
V 24
file 19.59e.r14246/20716
K 11
unittools.c
V 23
file 1a.59e.r15484/8925
K 11
unittools.h
V 23
file 1b.59e.r15484/9186
K 8
voting.c
V 25
file 4fc.59e.r15672/23092
K 8
voting.h
V 25
file 4fd.59e.r15671/13277
END
ENDREP
id: z.59e.r15673/68385
type: dir
pred: z.59e.r15672/27363
count: 3350
text: 15673 65099 3273 3273 bbcab0aa24d6544477aacdd33a3cc088
props: 13931 1856 101 0 347a75d6319334d09b8f5c63b7f32119
cpath: /branches/S2_1/server
copyroot: 11448 /branches/S2_1

id: 2f6.59e.r15673/68634
type: file
pred: 2f6.59e.r14678/53175
count: 178
text: 15673 1071 60216 748146 ea7849ac8faf2cc816d7199529624a61
props: 11057 30922 112 0 0fa1a75ff21762f9e3a6907a27ebf4e5
cpath: /branches/S2_1/common/packets_gen.c
copyroot: 11448 /branches/S2_1

id: 2f7.59e.r15673/68904
type: file
pred: 2f7.59e.r14678/53444
count: 155
text: 15673 61314 1209 62801 1d35129e533ed2456acbf345bbcfedef
props: 11057 31643 112 0 2824284b9d86d6d3a4539c5a01bdce8d
cpath: /branches/S2_1/common/packets_gen.h
copyroot: 11448 /branches/S2_1

PLAIN
K 11
Makefile.am
V 22
file 5h.0.r11391/39828
K 6
aicore
V 23
dir 18t.59e.r15557/1328
K 8
capstr.c
V 23
file dv.59e.r12018/5512
K 8
capstr.h
V 24
file dw.59e.r14881/26467
K 6
city.c
V 21
file q.59e.r15665/218
K 6
city.h
V 23
file 3q.59e.r14990/6164
K 8
combat.c
V 26
file wp.59e.r14203/1564387
K 8
combat.h
V 22
file wq.0.r11179/22662
K 12
connection.c
V 23
file un.59e.r15656/2353
K 12
connection.h
V 23
file uo.59e.r15656/2610
K 8
dataio.c
V 23
file 15r.59e.r14514/669
K 8
dataio.h
V 23
file 15s.0.r10480/10050
K 11
diptreaty.c
V 26
file 3r.59e.r14210/2244988
K 11
diptreaty.h
V 20
file 3s.0.r9582/5141
K 9
effects.c
V 25
file 2eo.59e.r13590/41672
K 9
effects.h
V 25
file 2ep.59e.r13590/41934
K 8
events.c
V 26
file 33h.59e.r14117/507151
K 8
events.h
V 24
file 3t.59e.r13524/15083
K 10
fc_types.h
V 25
file 2ll.59e.r13301/13007
K 6
game.c
V 23
file 3u.59e.r14876/1022
K 6
game.h
V 23
file 3v.59e.r14797/4194
K 19
generate_packets.py
V 25
file 2f4.59e.r14495/34877
K 12
government.c
V 24
file he.59e.r13301/13528
K 12
government.h
V 24
file hf.59e.r13044/52595
K 6
idex.c
V 26
file qo.59e.r14210/2249559
K 6
idex.h
V 21
file qp.0.r8119/15235
K 13
improvement.c
V 22
file vb.59e.r15653/907
K 13
improvement.h
V 23
file vc.59e.r15653/1165
K 5
map.c
V 24
file r.59e.r13925/183197
K 5
map.h
V 24
file 41.59e.r15385/27991
K 10
movement.c
V 26
file 2xv.59e.r13925/182149
K 10
movement.h
V 23
file 2xw.0.r10755/47420
K 8
nation.c
V 24
file il.59e.r14267/61523
K 8
nation.h
V 26
file im.59e.r14210/2249820
K 9
packets.c
V 23
file 43.59e.r14483/1132
K 11
packets.def
V 25
file 2f5.59e.r15672/27612
K 9
packets.h
V 24
file 44.59e.r13069/18292
K 13
packets_gen.c
V 25
file 2f6.59e.r15673/68634
K 13
packets_gen.h
V 25
file 2f7.59e.r15673/68904
K 8
player.c
V 23
file 45.59e.r15044/7958
K 8
player.h
V 23
file 46.59e.r15044/8215
K 14
requirements.c
V 25
file 2wq.59e.r14946/10659
K 14
requirements.h
V 25
file 2wr.59e.r13590/42465
K 11
spaceship.c
V 20
file 98.0.r9977/2632
K 11
spaceship.h
V 20
file 99.0.r9977/2979
K 12
specialist.c
V 22
file 33f.0.r10490/6920
K 12
specialist.h
V 22
file 33g.0.r10490/7274
K 6
team.c
V 25
file 33i.59e.r14257/22796
K 6
team.h
V 23
file 33j.0.r10866/16021
K 6
tech.c
V 22
file t.59e.r14981/7150
K 6
tech.h
V 23
file u.59e.r14257/23048
K 9
terrain.c
V 25
file 2fp.59e.r14946/10141
K 9
terrain.h
V 24
file qs.59e.r14946/10402
K 6
tile.c
V 26
file 2ys.59e.r13925/182416
K 6
tile.h
V 24
file 2yt.59e.r14697/1442
K 6
unit.c
V 20
file v.59e.r15576/60
K 6
unit.h
V 24
file 48.59e.r14246/24474
K 10
unitlist.c
V 27
file 39m.59e.r14210/2248234
K 10
unitlist.h
V 27
file 39n.59e.r14210/2248760
K 10
unittype.c
V 23
file v9.59e.r15653/1422
K 10
unittype.h
V 24
file va.59e.r13044/50511
K 9
version.c
V 19
file oe.0.r11233/55
K 9
version.h
V 23
file e7.59e.r11550/2812
K 10
worklist.c
V 25
file o8.59e.r13028/197456
K 10
worklist.h
V 22
file o9.59e.r13338/305
END
ENDREP
id: p.59e.r15673/72061
type: dir
pred: p.59e.r15672/30765
count: 2289
text: 15673 69173 2875 2875 0439e3637438bab3231f3c6cdcff85fa
props: 11108 11015 68 0 29f6aad3a983ad5efd94235c6b41039e
cpath: /branches/S2_1/common
copyroot: 11448 /branches/S2_1

id: 2fn.59e.r15673/72310
type: file
pred: 2fn.59e.r13744/60709
count: 21
text: 15673 0 709 10265 ceaa2d56391b88eeee0df39856852810
props: 10951 18127 111 0 2a5912525b098cb46a1301ee940f7617
cpath: /branches/S2_1/client/packhand_gen.c
copyroot: 11448 /branches/S2_1

id: 2f3.59e.r15673/72574
type: file
pred: 2f3.59e.r13744/60977
count: 23
text: 15673 738 304 5990 69c491d5d977e342190f41000a8b2ba1
props: 10951 18486 111 0 4b4193808cb95e702a5e5065e4345324
cpath: /branches/S2_1/client/packhand_gen.h
copyroot: 11448 /branches/S2_1

PLAIN
K 11
Makefile.am
V 24
file 5f.59e.r15671/17587
K 6
agents
V 23
dir zf.59e.r15267/36264
K 11
attribute.c
V 23
file xh.59e.r15628/4449
K 11
attribute.h
V 19
file xi.0.r4715/844
K 7
audio.c
V 26
file 139.59e.r14019/355442
K 7
audio.h
V 22
file 13a.0.r10416/6162
K 12
audio_none.c
V 23
file 13d.0.r6129/145164
K 12
audio_none.h
V 22
file 13e.0.r4452/27228
K 11
audio_sdl.c
V 26
file 13f.59e.r13353/153791
K 11
audio_sdl.h
V 22
file 13g.0.r4452/26570
K 17
chatline_common.c
V 23
file 14q.0.r9577/151065
K 17
chatline_common.h
V 23
file 14r.0.r9577/151422
K 16
citydlg_common.c
V 24
file z4.59e.r15267/36519
K 16
citydlg_common.h
V 24
file z5.59e.r13911/39085
K 13
cityrepdata.c
V 23
file mb.59e.r15518/2949
K 13
cityrepdata.h
V 21
file mc.0.r9153/21475
K 11
civclient.c
V 24
file 2f.59e.r15672/55215
K 11
civclient.h
V 24
file hz.59e.r14152/15223
K 8
climap.c
V 23
file 197.0.r11057/48047
K 8
climap.h
V 25
file 198.59e.r13916/11829
K 9
climisc.c
V 23
file d5.59e.r15564/2233
K 9
climisc.h
V 23
file i0.59e.r15502/5967
K 8
clinet.c
V 24
file hc.59e.r14161/24174
K 8
clinet.h
V 24
file i1.59e.r12485/13819
K 15
colors_common.c
V 27
file 33a.59e.r13033/1319887
K 15
colors_common.h
V 24
file 33b.59e.r13016/9994
K 19
connectdlg_common.c
V 23
file 2fw.59e.r15441/970
K 19
connectdlg_common.h
V 27
file 2fx.59e.r14210/2301973
K 9
control.c
V 24
file gz.59e.r15538/10707
K 9
control.h
V 24
file i2.59e.r15538/14844
K 11
ggzclient.c
V 25
file 394.59e.r12671/53764
K 11
ggzclient.h
V 25
file 395.59e.r12671/54072
K 6
goto.c
V 23
file vu.59e.r15516/7720
K 6
goto.h
V 24
file vv.59e.r15508/23547
K 8
gui-ftwl
V 24
dir 2k2.59e.r15672/52109
K 11
gui-gtk-2.0
V 23
dir zs.59e.r15672/34632
K 7
gui-mui
V 22
dir km.59e.r14357/8973
K 7
gui-sdl
V 24
dir 16t.59e.r15672/49032
K 8
gui-stub
V 23
dir mh.59e.r15672/54954
K 9
gui-win32
V 23
dir np.59e.r15672/43327
K 7
gui-xaw
V 23
dir 9o.59e.r15672/38212
K 10
helpdata.c
V 24
file h1.59e.r15415/10674
K 10
helpdata.h
V 26
file i3.59e.r14233/1635572
K 7
include
V 23
dir b8.59e.r15672/40009
K 16
mapctrl_common.c
V 25
file 15m.59e.r15508/24065
K 16
mapctrl_common.h
V 23
file 15n.0.r11378/41712
K 16
mapview_common.c
V 24
file z2.59e.r15670/16181
K 16
mapview_common.h
V 24
file z3.59e.r15508/24604
K 19
messagewin_common.c
V 23
file 14s.0.r11057/47330
K 19
messagewin_common.h
V 23
file 14t.0.r8387/154818
K 9
options.c
V 24
file dc.59e.r15532/16411
K 9
options.h
V 24
file i4.59e.r15532/15894
K 17
overview_common.c
V 26
file 2yk.59e.r13925/192137
K 17
overview_common.h
V 21
file 2yl.0.r10927/997
K 10
packhand.c
V 23
file n.59e.r15672/43586
K 10
packhand.h
V 22
file i5.0.r10865/39236
K 14
packhand_gen.c
V 25
file 2fn.59e.r15673/72310
K 14
packhand_gen.h
V 25
file 2f3.59e.r15673/72574
K 15
plrdlg_common.c
V 27
file 14u.59e.r14210/2292817
K 15
plrdlg_common.h
V 23
file 14v.0.r10581/10242
K 17
repodlgs_common.c
V 23
file 11i.59e.r15167/339
K 17
repodlgs_common.h
V 25
file 11j.59e.r14161/23904
K 9
reqtree.c
V 24
file 2ym.59e.r14069/1075
K 9
reqtree.h
V 25
file 2yn.59e.r13482/23394
K 9
servers.c
V 25
file 33x.59e.r15504/30475
K 9
servers.h
V 24
file 33y.59e.r15617/4925
K 6
text.c
V 25
file 2g3.59e.r15562/11714
K 6
text.h
V 27
file 2g4.59e.r14245/1012129
K 15
themes_common.c
V 25
file 352.59e.r13237/37501
K 15
themes_common.h
V 25
file 353.59e.r13237/37764
K 10
tilespec.c
V 24
file hl.59e.r15508/23803
K 10
tilespec.h
V 23
file i6.59e.r15232/3345
K 10
voteinfo.c
V 25
file 4fa.59e.r15671/17235
K 10
voteinfo.h
V 25
file 4fb.59e.r15671/17410
END
ENDREP
id: d.59e.r15673/76333
type: dir
pred: d.59e.r15672/58968
count: 4168
text: 15673 72839 3481 3481 f6a46b1d21369794552c12a08d0e60b9
props: 8351 6991 78 0 33732c0866155f66d4d419b596dde5d8
cpath: /branches/S2_1/client
copyroot: 11448 /branches/S2_1

PLAIN
K 9
ABOUT-NLS
V 21
file fu.0.r3960/17632
K 7
AUTHORS
V 22
file 5u.59e.r13248/152
K 7
COPYING
V 19
file 1h.0.r9643/400
K 9
ChangeLog
V 25
file 6l.59e.r15608/963412
K 7
INSTALL
V 20
file 6.59e.r14673/94
K 11
Makefile.am
V 21
file 59.59e.r14919/55
K 4
NEWS
V 23
file 6m.59e.r15594/3279
K 6
README
V 20
file 7.0.r4421/96382
K 2
ai
V 21
dir 8.59e.r15397/4426
K 5
amiga
V 21
dir kd.0.r11105/71924
K 10
autogen.sh
V 23
file 12o.59e.r15553/627
K 9
bootstrap
V 24
dir 2p5.59e.r14780/13984
K 6
client
V 22
dir d.59e.r15673/76333
K 6
common
V 22
dir p.59e.r15673/72061
K 12
config.mac.h
V 20
file hb.0.r6045/5982
K 12
configure.ac
V 24
file 149.59e.r15425/2420
K 4
data
V 22
dir w.59e.r15530/10475
K 6
debian
V 22
dir 5w.59e.r13442/7411
K 12
dependencies
V 21
dir 2yu.0.r11108/3256
K 11
diff_ignore
V 23
file qq.59e.r13228/2550
K 3
doc
V 22
dir k7.59e.r14600/3039
K 4
intl
V 21
dir f4.0.r11105/23499
K 2
m4
V 23
dir 12p.59e.r15639/2558
K 6
manual
V 26
dir 2m2.59e.r14210/2260417
K 2
po
V 24
dir fs.59e.r15604/274934
K 7
scripts
V 23
dir 2yo.59e.r14811/1235
K 6
server
V 22
dir z.59e.r15673/68385
K 10
stamp-h.in
V 19
file 80.0.r1125/241
K 5
tests
V 23
dir 2g9.59e.r13446/1204
K 7
utility
V 22
dir 1c.59e.r15655/3061
K 10
version.in
V 25
file 2lo.59e.r15672/21535
K 3
vms
V 21
dir u9.0.r11105/70719
K 5
win32
V 24
dir 2eu.59e.r13979/10719
END
ENDREP
id: 3.59e.r15673/77924
type: dir
pred: 3.59e.r15672/60559
count: 11570
text: 15673 76580 1331 1331 d840d1cad261c5058ac44150bfec8d80
props: 11109 0 255 0 8cbc80e0da9c47b05b8ffee17ea9b0f1
cpath: /branches/S2_1
copyroot: 11448 /branches/S2_1

PLAIN
K 5
S1_14
V 20
dir 3.21.r15224/4547
K 4
S2_0
V 21
dir 3.10x.r15558/5273
K 4
S2_1
V 22
dir 3.59e.r15673/77924
K 11
freeciv-web
V 22
dir 3.5bl.r13594/14918
END
ENDREP
id: 1.0.r15673/78335
type: dir
pred: 1.0.r15672/60970
count: 3501
text: 15673 78164 158 158 1327c961408edd80d73e7cb0cf67bae8
cpath: /branches
copyroot: 0 /

PLAIN
K 8
branches
V 20
dir 1.0.r15673/78335
K 4
tags
V 21
dir 2.0.r15609/968232
K 5
trunk
V 21
dir 3.5ck.r15668/5940
K 7
website
V 18
dir 3ge.0.r12388/0
END
ENDREP
id: 0.0.r15673/78657
type: dir
pred: 0.0.r15672/61292
count: 15673
text: 15673 78492 152 152 b167913310c97c406235c34dd7129395
cpath: /
copyroot: 0 /

2fo.59e.t15672-1 modify true false /branches/S2_1/server/hand_gen.c

2f6.59e.t15672-1 modify true false /branches/S2_1/common/packets_gen.c

2f9.59e.t15672-1 modify true false /branches/S2_1/server/hand_gen.h

2fn.59e.t15672-1 modify true false /branches/S2_1/client/packhand_gen.c

2f7.59e.t15672-1 modify true false /branches/S2_1/common/packets_gen.h

2f3.59e.t15672-1 modify true false /branches/S2_1/client/packhand_gen.h


78657 78807