extra2[cnt] = SWAPU32 (extra2[cnt]);
extra2[cnt] = SWAPU32 (extra[cnt]);
collate_output (struct localedef_t *locale, struct charset_t *charset,		const char *output_path){  struct locale_collate_t *collate = locale->categories[LC_COLLATE].collate;  u_int32_t table_size, table_best, level_best, sum_best;  void *last;  element_t *pelem;  wchar_t *name;  size_t len;  const size_t nelems = _NL_ITEM_INDEX (_NL_NUM_LC_COLLATE);  struct iovec iov[2 + nelems];  struct locale_file data;  u_int32_t idx[nelems];  struct obstack non_simple;  struct obstack string_pool;  size_t cnt, entry_size;  u_int32_t undefined_offset = UINT_MAX;  u_int32_t *table, *extra, *table2, *extra2;  size_t extra_len;  u_int32_t element_hash_tab_size;  u_int32_t *element_hash_tab;  u_int32_t *element_hash_tab_ob;  u_int32_t element_string_pool_size;  char *element_string_pool;  u_int32_t element_value_size;  wchar_t *element_value;  wchar_t *element_value_ob;  u_int32_t symbols_hash_tab_size;  u_int32_t *symbols_hash_tab;  u_int32_t *symbols_hash_tab_ob;  u_int32_t symbols_string_pool_size;  char *symbols_string_pool;  u_int32_t symbols_class_size;  u_int32_t *symbols_class;  u_int32_t *symbols_class_ob;  hash_table *hash_tab;  unsigned int dummy_weights[collate->nrules + 1];  sum_best = UINT_MAX;  table_best = 0xffff;  level_best = 0xffff;  /* Compute table size.  */  if (!be_quiet)    fputs (_("\Computing table size for collation information might take a while..."),	   stderr);  for (table_size = 256; table_size < sum_best; ++table_size)    {      size_t hits[table_size];      unsigned int worst = 1;      size_t cnt;      last = NULL;      for (cnt = 0; cnt < 256; ++cnt)	hits[cnt] = 1;      memset (&hits[256], '\0', sizeof (hits) - 256 * sizeof (size_t));      while (iterate_table (&collate->result, &last, (const void **) &name,			    &len, (void **) &pelem) >= 0)	if (pelem->ordering != NULL && pelem->name[0] > 0xff)	  if (++hits[(unsigned int) pelem->name[0] % table_size] > worst)	    {	      worst = hits[(unsigned int) pelem->name[0] % table_size];	      if (table_size * worst > sum_best)		break;	    }      if (table_size * worst < sum_best)	{	  sum_best = table_size * worst;	  table_best = table_size;	  level_best = worst;	}    }  assert (table_best != 0xffff || level_best != 0xffff);  if (!be_quiet)    fputs (_(" done\n"), stderr);  obstack_init (&non_simple);  obstack_init (&string_pool);  data.magic = LIMAGIC (LC_COLLATE);  data.n = nelems;  iov[0].iov_base = (void *) &data;  iov[0].iov_len = sizeof (data);  iov[1].iov_base = (void *) idx;  iov[1].iov_len = sizeof (idx);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_NRULES)].iov_base = &collate->nrules;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_NRULES)].iov_len = sizeof (u_int32_t);  table = (u_int32_t *) alloca (collate->nrules * sizeof (u_int32_t));  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_RULES)].iov_base = table;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_RULES)].iov_len    = collate->nrules * sizeof (u_int32_t);  /* Another trick here.  Describing the collation method needs only a     few bits (3, to be exact).  But the binary file should be     accessible by machines with both endianesses and so we store both     forms in the same word.  */  for (cnt = 0; cnt < collate->nrules; ++cnt)    table[cnt] = collate->rules[cnt] | SWAPU32 (collate->rules[cnt]);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_SIZE)].iov_base = &table_best;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_SIZE)].iov_len = sizeof (u_int32_t);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_LAYERS)].iov_base = &level_best;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_HASH_LAYERS)].iov_len    = sizeof (u_int32_t);  entry_size = 1 + MAX (collate->nrules, 2);  table = (u_int32_t *) alloca (table_best * level_best * entry_size				* sizeof (table[0]));  memset (table, '\0', table_best * level_best * entry_size	  * sizeof (table[0]));  /* Macros for inserting in output table.  */#define ADD_VALUE(expr)							      \  do {									      \    u_int32_t to_write = (u_int32_t) expr;				      \    obstack_grow (&non_simple, &to_write, sizeof (to_write));		      \  } while (0)#define ADD_ELEMENT(pelem, len)						      \  do {									      \    size_t cnt, idx;							      \									      \    ADD_VALUE (len);							      \									      \    wlen = wcslen (pelem->name);					      \    obstack_grow (&non_simple, pelem->name, (wlen + 1) * sizeof (u_int32_t)); \									      \    idx = collate->nrules;						      \    for (cnt = 0; cnt < collate->nrules; ++cnt)				      \      {									      \	size_t disp;							      \									      \	ADD_VALUE (pelem->ordering[cnt]);				      \	for (disp = 0; disp < pelem->ordering[cnt]; ++disp)		      \	  ADD_VALUE (pelem->ordering[idx++]);				      \      }									      \  } while (0)#define ADD_FORWARD(pelem)						      \  do {									      \    /* We leave a reference in the main table and put all		      \       information in the table for the extended entries.  */		      \    element_t *runp;							      \    element_t *has_simple = NULL;					      \    size_t wlen;							      \									      \    table[(level * table_best + slot) * entry_size + 1]			      \      = FORWARD_CHAR;							      \    table[(level * table_best + slot) * entry_size + 2]			      \      = obstack_object_size (&non_simple) / sizeof (u_int32_t);		      \									      \    /* Here we have to construct the non-simple table entry.  First	      \       compute the total length of this entry.  */			      \    for (runp = (pelem); runp != NULL; runp = runp->next)		      \      if (runp->ordering != NULL)					      \	{								      \	  u_int32_t value;						      \	  size_t cnt;							      \									      \	  value = 1 + wcslen (runp->name) + 1;				      \									      \	  for (cnt = 0; cnt < collate->nrules; ++cnt)			      \	    /* We have to take care for entries without ordering	      \	       information.  While reading them they get inserted in the      \	       table and later not removed when something goes wrong with     \	       reading its weights.  */					      \	    value += 1 + runp->ordering[cnt];				      \									      \	  if (runp->name[1] == L'\0')					      \	    has_simple = runp;						      \									      \	  ADD_ELEMENT (runp, value);					      \	}								      \									      \    if (has_simple == NULL)						      \      {									      \	size_t idx, cnt;						      \									      \	ADD_VALUE (collate->undefined_len + 1);				      \									      \	/* Add the name.  */						      \	ADD_VALUE ((pelem)->name[0]);					      \	ADD_VALUE (0);							      \									      \	idx = collate->nrules;						      \	for (cnt = 0; cnt < collate->nrules; ++cnt)			      \	  {								      \	    size_t disp;						      \									      \	    ADD_VALUE (collate->undefined.ordering[cnt]);		      \	    for (disp = 0; disp < collate->undefined.ordering[cnt]; ++disp)   \	      {								      \		if ((wchar_t) collate->undefined.ordering[idx]		      \		    == ELLIPSIS_CHAR)					      \		  ADD_VALUE ((pelem)->name[0]);				      \		else							      \		  ADD_VALUE (collate->undefined.ordering[idx++]);	      \		++idx;							      \	      }								      \	  }								      \      }									      \  } while (0)  /* Fill the table now.  First we look for all the characters which     fit into one single byte.  This speeds up the 8-bit string     functions.  */  last = NULL;  while (iterate_table (&collate->result, &last, (const void **) &name,			&len, (void **) &pelem) >= 0)    if (pelem->name[0] <= 0xff)      {	/* We have a single byte name.  Now we must distinguish	   between entries in simple form (i.e., only one value per	   weight and no collation element starting with the same	   character) and those which are not.  */	size_t slot = ((size_t) pelem->name[0]);	const size_t level = 0;	table[slot * entry_size] = pelem->name[0];	if (pelem->name[1] == L'\0' && pelem->next == NULL	    && pelem->ordering_len == collate->nrules)	  {	    /* Yes, we have a simple one.  Lucky us.  */	    size_t cnt;	    for (cnt = 0; cnt < collate->nrules; ++cnt)	      table[slot * entry_size + 1 + cnt]		= pelem->ordering[collate->nrules + cnt];	  }	else	  ADD_FORWARD (pelem);      }  /* Now check for missing single byte entries.  If one exist we fill     with the UNDEFINED entry.  */  for (cnt = 0; cnt < 256; ++cnt)    /* The first weight is never 0 for existing entries.  */    if (table[cnt * entry_size + 1] == 0)      {	/* We have to fill in the information from the UNDEFINED	   entry.  */	table[cnt * entry_size] = (u_int32_t) cnt;	if (collate->undefined.ordering_len == collate->nrules)	  {	    size_t inner;	    for (inner = 0; inner < collate->nrules; ++inner)	      if ((wchar_t)collate->undefined.ordering[collate->nrules + inner]		  == ELLIPSIS_CHAR)		table[cnt * entry_size + 1 + inner] = cnt;	      else		table[cnt * entry_size + 1 + inner]		  = collate->undefined.ordering[collate->nrules + inner];	  }	else	  {	    if (undefined_offset != UINT_MAX)	      {		table[cnt * entry_size + 1] = FORWARD_CHAR;		table[cnt * entry_size + 2] = undefined_offset;	      }	    else	      {		const size_t slot = cnt;		const size_t level = 0;		ADD_FORWARD (&collate->undefined);		undefined_offset = table[cnt * entry_size + 2];	      }	  }      }  /* Now we are ready for inserting the whole rest.   */  last = NULL;  while (iterate_table (&collate->result, &last, (const void **) &name,			&len, (void **) &pelem) >= 0)    if (pelem->name[0] > 0xff)      {	/* Find the position.  */	size_t slot = ((size_t) pelem->name[0]) % table_best;	size_t level = 0;	while (table[(level * table_best + slot) * entry_size + 1] != 0)	  ++level;	assert (level < level_best);	if (pelem->name[1] == L'\0' && pelem->next == NULL	    && pelem->ordering_len == collate->nrules)	  {	    /* Again a simple entry.  */	    size_t inner;	    for (inner = 0; inner < collate->nrules; ++inner)	      table[(level * table_best + slot) * entry_size + 1 + inner]		= pelem->ordering[collate->nrules + inner];	  }	else	  ADD_FORWARD (pelem);      }  /* Add the UNDEFINED entry.  */  {    /* Here we have to construct the non-simple table entry.  */    size_t idx, cnt;    undefined_offset = obstack_object_size (&non_simple);    idx = collate->nrules;    for (cnt = 0; cnt < collate->nrules; ++cnt)      {	size_t disp;	ADD_VALUE (collate->undefined.ordering[cnt]);	for (disp = 0; disp < collate->undefined.ordering[cnt]; ++disp)	  ADD_VALUE (collate->undefined.ordering[idx++]);      }  }  /* Finish the extra block.  */  extra_len = obstack_object_size (&non_simple);  extra = (u_int32_t *) obstack_finish (&non_simple);  assert ((extra_len % sizeof (u_int32_t)) == 0);  /* Now we have to build the two array for the other byte ordering.  */  table2 = (u_int32_t *) alloca (table_best * level_best * entry_size				 * sizeof (table[0]));  extra2 = (u_int32_t *) alloca (extra_len);  for (cnt = 0; cnt < table_best * level_best * entry_size; ++cnt)    table2[cnt] = SWAPU32 (table[cnt]);  for (cnt = 0; cnt < extra_len / sizeof (u_int32_t); ++cnt)    extra2[cnt] = SWAPU32 (extra2[cnt]);  /* We need a simple hashing table to get a collation-element->chars     mapping.  We again use internal hashing using a secondary hashing     function.     Each string has an associate hashing value V, computed by a     fixed function.  To locate the string we use open addressing with     double hashing.  The first index will be V % M, where M is the     size of the hashing table.  If no entry is found, iterating with     a second, independent hashing function takes place.  This second     value will be 1 + V % (M - 2).  The approximate number of probes     will be	  for unsuccessful search: (1 - N / M) ^ -1	  for successful search:   - (N / M) ^ -1 * ln (1 - N / M)     where N is the number of keys.     If we now choose M to be the next prime bigger than 4 / 3 * N,     we get the values 4 and 1.85 resp.  Because unsuccessful searches     are unlikely this is a good value.  Formulas: [Knuth, The Art of     Computer Programming, Volume 3, Sorting and Searching, 1973,     Addison Wesley]  */  if (collate->elements.filled == 0)    {      /* We don't need any element table since there are no collating	 elements.  */      element_hash_tab_size = 0;      element_hash_tab = NULL;      element_hash_tab_ob = NULL;      element_string_pool_size = 0;      element_string_pool = NULL;      element_value_size = 0;      element_value = NULL;      element_value_ob = NULL;    }  else    {      void *ptr;		/* Running pointer.  */      const char *key;		/* Key for current bucket.  */      size_t keylen;		/* Length of key data.  */      const element_t *data;	/* Data, i.e., the character sequence.  */      element_hash_tab_size = next_prime ((collate->elements.filled * 4) / 3);      if (element_hash_tab_size < 7)	/* We need a minimum to make the following code work.  */	element_hash_tab_size = 7;      element_hash_tab = obstack_alloc (&non_simple, (2 * element_hash_tab_size						      * sizeof (u_int32_t)));      memset (element_hash_tab, '\377', (2 * element_hash_tab_size					 * sizeof (u_int32_t)));      ptr = NULL;      while (iterate_table (&collate->elements, &ptr, (const void **) &key,			    &keylen, (void **) &data) == 0)	{	  size_t hash_val = hash_string (key, keylen);	  size_t idx = hash_val % element_hash_tab_size;	  if (element_hash_tab[2 * idx] != (~((u_int32_t) 0)))	    {	      /* We need the second hashing function.  */	      size_t c = 1 + (hash_val % (element_hash_tab_size - 2));	      do		if (idx >= element_hash_tab_size - c)		  idx -= element_hash_tab_size - c;		else		  idx += c;	      while (element_hash_tab[2 * idx] != (~((u_int32_t) 0)));	    }	  element_hash_tab[2 * idx] = obstack_object_size (&non_simple);	  element_hash_tab[2 * idx + 1] = (obstack_object_size (&string_pool)					   / sizeof (wchar_t));	  obstack_grow0 (&non_simple, key, keylen);	  obstack_grow (&string_pool, data->name,			(wcslen (data->name) + 1) * sizeof (wchar_t));	}      if (obstack_object_size (&non_simple) % 4 != 0)	obstack_blank (&non_simple,		       4 - (obstack_object_size (&non_simple) % 4));      element_string_pool_size = obstack_object_size (&non_simple);      element_string_pool = obstack_finish (&non_simple);      element_value_size = obstack_object_size (&string_pool);      element_value = obstack_finish (&string_pool);      /* Create the tables for the other byte order.  */      element_hash_tab_ob = obstack_alloc (&non_simple,					   (2 * element_hash_tab_size					    * sizeof (u_int32_t)));      for (cnt = 0; cnt < 2 * element_hash_tab_size; ++cnt)	element_hash_tab_ob[cnt] = SWAPU32 (element_hash_tab[cnt]);      element_value_ob = obstack_alloc (&string_pool, element_value_size);      if (sizeof (wchar_t) != 4)	{	  fputs ("sizeof (wchar_t) != 4 currently not handled", stderr);	  abort ();	}      for (cnt = 0; cnt < element_value_size / 4; ++cnt)	element_value_ob[cnt] = SWAPU32 (element_value[cnt]);    }  /* Store collation elements as map to collation class.  There are     three kinds of symbols:       - simple characters       - collation elements       - collation symbols     We need to make a table which lets the user to access the primary     weight based on the symbol string.  */  symbols_hash_tab_size = next_prime ((4 * (charset->char_table.filled					    + collate->elements.filled					    + collate->symbols.filled)) / 3);  symbols_hash_tab = obstack_alloc (&non_simple, (2 * symbols_hash_tab_size						  * sizeof (u_int32_t)));  memset (symbols_hash_tab, '\377', (2 * symbols_hash_tab_size				     * sizeof (u_int32_t)));  /* Now fill the array.  First the symbols from the character set,     then the collation elements and last the collation symbols.  */  hash_tab = &charset->char_table;  while (1)    {      void *ptr;	/* Running pointer.  */      const char *key;	/* Key for current bucket.  */      size_t keylen;	/* Length of key data.  */      void *data;	/* Data.  */      ptr = NULL;      while (iterate_table (hash_tab, &ptr, (const void **) &key,			    &keylen, (void **) &data) == 0)	{	  size_t hash_val;	  size_t idx;	  u_int32_t word;	  unsigned int *weights;	  if (hash_tab == &charset->char_table	      || hash_tab == &collate->elements)	    {	      element_t *lastp, *firstp;	      wchar_t dummy_name[2];	      const wchar_t *name;	      size_t name_len;	      if (hash_tab == &charset->char_table)		{		  dummy_name[0] = (wchar_t) ((unsigned long int) data);		  dummy_name[1] = L'\0';		  name = dummy_name;		  name_len = sizeof (wchar_t);		}	      else		{		  element_t *elemp = (element_t *) data;		  name = elemp->name;		  name_len = wcslen (name) * sizeof (wchar_t);		}	      /* First check whether this character is used at all.  */	      if (find_entry (&collate->result, name, name_len,			      (void *) &firstp) < 0)		/* The symbol is not directly mentioned in the collation.		   I.e., we use the value for UNDEFINED.  */		lastp = &collate->undefined;	      else		{		  /* The entry for the simple character is always found at		     the end.  */		  lastp = firstp;		  while (lastp->next != NULL && wcscmp (name, lastp->name))		    lastp = lastp->next;		  if (lastp->ordering == NULL)		    lastp = &collate->undefined;		}	      weights = lastp->ordering;	    }	  else	    {	      dummy_weights[0] = 1;	      dummy_weights[collate->nrules]		= (unsigned int) ((unsigned long int) data);	      weights = dummy_weights;	    }	  /* In LASTP->ordering we now have the collation class.	     Determine the place in the hashing table next.  */	  hash_val = hash_string (key, keylen);	  idx = hash_val % symbols_hash_tab_size;	  if (symbols_hash_tab[2 * idx] != (~((u_int32_t) 0)))	    {	      /* We need the second hashing function.  */	      size_t c = 1 + (hash_val % (symbols_hash_tab_size - 2));	      do		if (idx >= symbols_hash_tab_size - c)		  idx -= symbols_hash_tab_size - c;		else		  idx += c;	      while (symbols_hash_tab[2 * idx] != (~((u_int32_t) 0)));	    }	  symbols_hash_tab[2 * idx] = obstack_object_size (&string_pool);	  symbols_hash_tab[2 * idx + 1] = (obstack_object_size (&non_simple)					   / sizeof (u_int32_t));	  obstack_grow0 (&string_pool, key, keylen);	  /* Adding the first weight looks complicated.  We have to deal	     with the kind it is stored and with the fact that original	     form uses `unsigned int's while we need `u_int32_t' here.  */	  word = weights[0];	  obstack_grow (&non_simple, &word, sizeof (u_int32_t));	  for (cnt = 0; cnt < weights[0]; ++cnt)	    {	      word = weights[collate->nrules + cnt];	      obstack_grow (&non_simple, &word, sizeof (u_int32_t));	    }	}      if (hash_tab == &charset->char_table)	hash_tab = &collate->elements;      else if (hash_tab == &collate->elements)	hash_tab = &collate->symbols;      else	break;    }  /* Now we have the complete tables.  */  if (obstack_object_size (&string_pool) % 4 != 0)    obstack_blank (&non_simple, 4 - (obstack_object_size (&string_pool) % 4));  symbols_string_pool_size = obstack_object_size (&string_pool);  symbols_string_pool = obstack_finish (&string_pool);  symbols_class_size = obstack_object_size (&non_simple);  symbols_class = obstack_finish (&non_simple);  /* Generate tables with other byte order.  */  symbols_hash_tab_ob = obstack_alloc (&non_simple, (2 * symbols_hash_tab_size						     * sizeof (u_int32_t)));  for (cnt = 0; cnt < 2 * symbols_hash_tab_size; ++cnt)    symbols_hash_tab_ob[cnt] = SWAPU32 (symbols_hash_tab[cnt]);  symbols_class_ob = obstack_alloc (&non_simple, symbols_class_size);  for (cnt = 0; cnt < symbols_class_size / 4; ++cnt)    symbols_class_ob[cnt] = SWAPU32 (symbols_class[cnt]);  /* Store table addresses and lengths.   */#if __BYTE_ORDER == __BIG_ENDIAN  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_base = table;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_len    = table_best * level_best * entry_size * sizeof (table[0]);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_base = table2;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_len    = table_best * level_best * entry_size * sizeof (table[0]);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_base = extra;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_len = extra_len;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_base = extra2;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_len = extra_len;#else  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_base = table2;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EB)].iov_len    = table_best * level_best * entry_size * sizeof (table[0]);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_base = table;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_TABLE_EL)].iov_len    = table_best * level_best * entry_size * sizeof (table[0]);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_base = extra2;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EB)].iov_len = extra_len;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_base = extra;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_EXTRA_EL)].iov_len = extra_len;#endif  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_UNDEFINED)].iov_base = &undefined_offset;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_UNDEFINED)].iov_len = sizeof (u_int32_t);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_SIZE)].iov_base    = &element_hash_tab_size;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_SIZE)].iov_len    = sizeof (u_int32_t);#if __BYTE_ORDER == __BIG_ENDIAN  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_base    = element_hash_tab;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_len    = 2 * element_hash_tab_size * sizeof (u_int32_t);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_base    = element_hash_tab_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_len    = 2 * element_hash_tab_size * sizeof (u_int32_t);#else  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_base    = element_hash_tab;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EL)].iov_len    = 2 * element_hash_tab_size * sizeof (u_int32_t);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_base    = element_hash_tab_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_HASH_EB)].iov_len    = 2 * element_hash_tab_size * sizeof (u_int32_t);#endif  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_STR_POOL)].iov_base    = element_string_pool;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_STR_POOL)].iov_len    = element_string_pool_size;#if __BYTE_ORDER == __BIG_ENDIAN  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_base    = element_value;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_len    = element_value_size;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_base    = element_value_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_len    = element_value_size;#else  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_base    = element_value;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EL)].iov_len    = element_value_size;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_base    = element_value_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_ELEM_VAL_EB)].iov_len    = element_value_size;#endif  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_SIZE)].iov_base    = &symbols_hash_tab_size;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_SIZE)].iov_len    = sizeof (u_int32_t);#if __BYTE_ORDER == __BIG_ENDIAN  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_base    = symbols_hash_tab;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_len    = 2 * symbols_hash_tab_size * sizeof (u_int32_t);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_base    = symbols_hash_tab_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_len    = 2 * symbols_hash_tab_size * sizeof (u_int32_t);#else  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_base    = symbols_hash_tab;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EL)].iov_len    = 2 * symbols_hash_tab_size * sizeof (u_int32_t);  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_base    = symbols_hash_tab_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_HASH_EB)].iov_len    = 2 * symbols_hash_tab_size * sizeof (u_int32_t);#endif  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_STR_POOL)].iov_base    = symbols_string_pool;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_STR_POOL)].iov_len    = symbols_string_pool_size;#if __BYTE_ORDER == __BIG_ENDIAN  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_base    = symbols_class;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_len    = symbols_class_size;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_base    = symbols_class_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_len    = symbols_class_size;#else  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_base    = symbols_class;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EL)].iov_len    = symbols_class_size;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_base    = symbols_class_ob;  iov[2 + _NL_ITEM_INDEX (_NL_COLLATE_SYMB_CLASS_EB)].iov_len    = symbols_class_size;#endif  /* Update idx array.  */  idx[0] = iov[0].iov_len + iov[1].iov_len;  for (cnt = 1; cnt < nelems; ++cnt)    idx[cnt] = idx[cnt - 1] + iov[1 + cnt].iov_len;  write_locale_data (output_path, "LC_COLLATE", 2 + nelems, iov);  obstack_free (&non_simple, NULL);  obstack_free (&string_pool, NULL);}