rem: CMP_WITH_IGNORE (translate[UCHAR (*texta)], translate[UCHAR (*textb)]);
add: CMP_WITH_IGNORE (translate[to_uchar (*texta)], translate[to_uchar (*textb)]);
context: keycompare (const struct line *a, const struct line *b){  struct keyfield *key = keylist;  /* For the first iteration only, the key positions have been     precomputed for us. */  register char *texta = a->keybeg;  register char *textb = b->keybeg;  register char *lima = a->keylim;  register char *limb = b->keylim;  int diff;  for (;;)    {      register unsigned char *translate = (unsigned char *) key->translate;      register int *ignore = key->ignore;      /* Find the lengths. */      size_t lena = lima <= texta ? 0 : lima - texta;      size_t lenb = limb <= textb ? 0 : limb - textb;      if (key->skipeblanks)	{	  char *a_end = texta + lena;	  char *b_end = textb + lenb;	  trim_trailing_blanks (texta, &a_end);	  trim_trailing_blanks (textb, &b_end);	  lena = a_end - texta;	  lenb = b_end - textb;	}      /* Actually compare the fields. */      if (key->numeric | key->general_numeric)	{	  char savea = *lima, saveb = *limb;	  *lima = *limb = '\0';	  diff = ((key->numeric ? numcompare : general_numcompare)		  (texta, textb));	  *lima = savea, *limb = saveb;	}      else if (key->month)	diff = getmonth (texta, lena) - getmonth (textb, lenb);      /* Sorting like this may become slow, so in a simple locale the user         can select a faster sort that is similar to ascii sort  */      else if (HAVE_SETLOCALE && hard_LC_COLLATE)	{	  if (ignore || translate)	    {	      char *copy_a = (char *) alloca (lena + 1 + lenb + 1);	      char *copy_b = copy_a + lena + 1;	      size_t new_len_a, new_len_b, i;	      /* Ignore and/or translate chars before comparing.  */	      for (new_len_a = new_len_b = i = 0; i < max (lena, lenb); i++)		{		  if (i < lena)		    {		      copy_a[new_len_a] = (translate					   ? translate[UCHAR (texta[i])]					   : texta[i]);		      if (!ignore || !ignore[UCHAR (texta[i])])			++new_len_a;		    }		  if (i < lenb)		    {		      copy_b[new_len_b] = (translate					   ? translate[UCHAR (textb[i])]					   : textb [i]);		      if (!ignore || !ignore[UCHAR (textb[i])])			++new_len_b;		    }		}	      diff = xmemcoll (copy_a, new_len_a, copy_b, new_len_b);	    }	  else if (lena == 0)	    diff = - NONZERO (lenb);	  else if (lenb == 0)	    goto greater;	  else	    diff = xmemcoll (texta, lena, textb, lenb);	}      else if (ignore)	{#define CMP_WITH_IGNORE(A, B)						\  do									\    {									\	  for (;;)							\	    {								\	      while (texta < lima && ignore[UCHAR (*texta)])		\		++texta;						\	      while (textb < limb && ignore[UCHAR (*textb)])		\		++textb;						\	      if (! (texta < lima && textb < limb))			\		break;							\	      diff = UCHAR (A) - UCHAR (B);				\	      if (diff)							\		goto not_equal;						\	      ++texta;							\	      ++textb;							\	    }								\									\	  diff = (texta < lima) - (textb < limb);			\    }									\  while (0)	  if (translate)	    CMP_WITH_IGNORE (translate[UCHAR (*texta)],			     translate[UCHAR (*textb)]);	  else	    CMP_WITH_IGNORE (UCHAR (*texta), UCHAR (*textb));	}      else if (lena == 0)	diff = - NONZERO (lenb);      else if (lenb == 0)	goto greater;      else	{	  if (translate)	    {	      while (texta < lima && textb < limb)		{		  diff = (UCHAR (translate[UCHAR (*texta++)])			  - UCHAR (translate[UCHAR (*textb++)]));		  if (diff)		    goto not_equal;		}	    }	  else	    {	      diff = memcmp (texta, textb, min (lena, lenb));	      if (diff)		goto not_equal;	    }	  diff = lena < lenb ? -1 : lena != lenb;	}      if (diff)	goto not_equal;      key = key->next;      if (! key)	break;      /* Find the beginning and limit of the next field.  */      if (key->eword != (size_t) -1)	lima = limfield (a, key), limb = limfield (b, key);      else	lima = a->text + a->length - 1, limb = b->text + b->length - 1;      if (key->sword != (size_t) -1)	texta = begfield (a, key), textb = begfield (b, key);      else	{	  texta = a->text, textb = b->text;	  if (key->skipsblanks)	    {	      while (texta < lima && blanks[UCHAR (*texta)])		++texta;	      while (textb < limb && blanks[UCHAR (*textb)])		++textb;	    }	}    }  return 0; greater:  diff = 1; not_equal:  return key->reverse ? -diff : diff;}