if (((MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
if (((MAX_NEEDED_FROM > 1 && MAX_NEEDED_TO > 1) || (MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,	       const unsigned char **inptrp, const unsigned char *inend,	       unsigned char **outbufstart, size_t *irreversible, int do_flush,	       int consume_incomplete){  struct __gconv_step *next_step = step + 1;  struct __gconv_step_data *next_data = data + 1;  __gconv_fct fct;  int status;  fct = (data->__flags & __GCONV_IS_LAST) ? NULL : next_step->__fct;  /* If the function is called with no input this means we have to reset     to the initial state.  The possibly partly converted input is     dropped.  */  if (__builtin_expect (do_flush, 0))    {      status = __GCONV_OK;      /* This should never happen during error handling.  */      assert (outbufstart == NULL);#ifdef EMIT_SHIFT_TO_INIT      /* Emit the escape sequence to reset the state.  */      EMIT_SHIFT_TO_INIT;#else      /* Clear the state object.  There might be bytes in there from	 previous calls with CONSUME_INCOMPLETE == 1.  */      memset (data->__statep, '\0', sizeof (*data->__statep));#endif      /* Call the steps down the chain if there are any but only if we         successfully emitted the escape sequence.  This should only	 fail if the output buffer is full.  If the input is invalid	 it should be discarded since the user wants to start from a	 clean slate.  */      if (status == __GCONV_OK && ! (data->__flags & __GCONV_IS_LAST))	status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,				    NULL, irreversible, 1,				    consume_incomplete));    }  else    {      /* We preserve the initial values of the pointer variables.  */      const unsigned char *inptr = *inptrp;      unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)			       ? data->__outbuf : *outbufstart);      unsigned char *outend = data->__outbufend;      unsigned char *outstart;      /* This variable is used to count the number of characters we	 actually converted.  */      size_t lirreversible = 0;      size_t *lirreversiblep = irreversible ? &lirreversible : NULL;#if defined _STRING_ARCH_unaligned \    || MIN_NEEDED_FROM == 1 || MAX_NEEDED_FROM % MIN_NEEDED_FROM != 0 \    || MIN_NEEDED_TO == 1 || MAX_NEEDED_TO % MIN_NEEDED_TO != 0# define unaligned 0#else      int unaligned;# define GEN_unaligned(name) GEN_unaligned2 (name)# define GEN_unaligned2(name) name##_unaligned#endif#ifdef PREPARE_LOOP      PREPARE_LOOP#endif#if MAX_NEEDED_FROM > 1 || MAX_NEEDED_TO > 1      /* If the function is used to implement the mb*towc*() or wc*tomb*()	 functions we must test whether any bytes from the last call are	 stored in the `state' object.  */      if (((MAX_NEEDED_FROM > 1 && FROM_DIRECTION)	   || (MAX_NEEDED_TO > 1 && !FROM_DIRECTION))	  && consume_incomplete && (data->__statep->__count & 7) != 0)	{	  /* Yep, we have some bytes left over.  Process them now.             But this must not happen while we are called from an             error handler.  */	  assert (outbufstart == NULL);# if MAX_NEEDED_FROM > 1	  if (MAX_NEEDED_TO == 1 || FROM_DIRECTION)	    status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,					outend, lirreversiblep					EXTRA_LOOP_ARGS);# endif# if MAX_NEEDED_FROM > 1 && MAX_NEEDED_TO > 1 && !ONE_DIRECTION	  else# endif# if MAX_NEEDED_TO > 1 && !ONE_DIRECTION	    status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,				      outend, lirreversiblep EXTRA_LOOP_ARGS);# endif	  if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)	    return status;	}#endif#if !defined _STRING_ARCH_unaligned \    && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \    && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0      /* The following assumes that encodings, which have a variable length	 what might unalign a buffer even though it is a aligned in the	 beginning, either don't have the minimal number of bytes as a divisor	 of the maximum length or have a minimum length of 1.  This is true	 for all known and supported encodings.  */      unaligned = ((FROM_DIRECTION		    && ((uintptr_t) inptr % MIN_NEEDED_FROM != 0			|| ((data->__flags & __GCONV_IS_LAST)			    && (uintptr_t) outbuf % MIN_NEEDED_TO != 0)))		   || (!FROM_DIRECTION		       && (((data->__flags & __GCONV_IS_LAST)			    && (uintptr_t) outbuf % MIN_NEEDED_FROM != 0)			   || (uintptr_t) inptr % MIN_NEEDED_TO != 0)));#endif      do	{	  struct __gconv_trans_data *trans;	  /* Remember the start value for this round.  */	  inptr = *inptrp;	  /* The outbuf buffer is empty.  */	  outstart = outbuf;#ifdef SAVE_RESET_STATE	  SAVE_RESET_STATE (1);#endif	  if (__builtin_expect (!unaligned, 1))	    {	      if (FROM_DIRECTION)		/* Run the conversion loop.  */		status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,				    lirreversiblep EXTRA_LOOP_ARGS);	      else		/* Run the conversion loop.  */		status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,				  lirreversiblep EXTRA_LOOP_ARGS);	    }#if !defined _STRING_ARCH_unaligned \    && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \    && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0	  else	    {	      if (FROM_DIRECTION)		/* Run the conversion loop.  */		status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,						    &outbuf, outend,						    lirreversiblep						    EXTRA_LOOP_ARGS);	      else		/* Run the conversion loop.  */		status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,						  &outbuf, outend,						  lirreversiblep						  EXTRA_LOOP_ARGS);	    }#endif	  /* If we were called as part of an error handling module we	     don't do anything else here.  */	  if (__builtin_expect (outbufstart != NULL, 0))	    {	      *outbufstart = outbuf;	      return status;	    }	  /* Give the transliteration module the chance to store the	     original text and the result in case it needs a context.  */	  for (trans = data->__trans; trans != NULL; trans = trans->__next)	    if (trans->__trans_context_fct != NULL)	      DL_CALL_FCT (trans->__trans_context_fct,			   (trans->__data, inptr, *inptrp, outstart, outbuf));	  /* We finished one use of the loops.  */	  ++data->__invocation_counter;	  /* If this is the last step leave the loop, there is nothing             we can do.  */	  if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))	    {	      /* Store information about how many bytes are available.  */	      data->__outbuf = outbuf;	      /* Remember how many non-identical characters we                 converted in a irreversible way.  */	      *irreversible += lirreversible;	      break;	    }	  /* Write out all output which was produced.  */	  if (__builtin_expect (outbuf > outstart, 1))	    {	      const unsigned char *outerr = data->__outbuf;	      int result;	      result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,					  outbuf, NULL, irreversible, 0,					  consume_incomplete));	      if (result != __GCONV_EMPTY_INPUT)		{		  if (__builtin_expect (outerr != outbuf, 0))		    {#ifdef RESET_INPUT_BUFFER		      RESET_INPUT_BUFFER;#else		      /* We have a problem with the in on of the functions			 below.  Undo the conversion upto the error point.  */		      size_t nstatus;		      /* Reload the pointers.  */		      *inptrp = inptr;		      outbuf = outstart;		      /* Reset the state.  */# ifdef SAVE_RESET_STATE		      SAVE_RESET_STATE (0);# endif		      /* XXX Handle unaligned access here as well.  */		      if (FROM_DIRECTION)			/* Run the conversion loop.  */			nstatus = FROM_LOOP (step, data,					     (const unsigned char **) inptrp,					     (const unsigned char *) inend,					     (unsigned char **) &outbuf,					     (unsigned char *) outerr,					     lirreversiblep EXTRA_LOOP_ARGS);		      else			/* Run the conversion loop.  */			nstatus = TO_LOOP (step, data,					   (const unsigned char **) inptrp,					   (const unsigned char *) inend,					   (unsigned char **) &outbuf,					   (unsigned char *) outerr,					   lirreversiblep EXTRA_LOOP_ARGS);		      /* We must run out of output buffer space in this			 rerun.  */		      assert (outbuf == outerr);		      assert (nstatus == __GCONV_FULL_OUTPUT);		      /* If we haven't consumed a single byte decrement			 the invocation counter.  */		      if (__builtin_expect (outbuf == outstart, 0))			--data->__invocation_counter;#endif	/* reset input buffer */		    }		  /* Change the status.  */		  status = result;		}	      else		/* All the output is consumed, we can make another run		   if everything was ok.  */		if (status == __GCONV_FULL_OUTPUT)		  status = __GCONV_OK;	    }	}      while (status == __GCONV_OK);#ifdef END_LOOP      END_LOOP#endif      /* If we are supposed to consume all character store now all of the	 remaining characters in the `state' object.  */#if MAX_NEEDED_FROM > 1 || MAX_NEEDED_TO > 1      if (((MAX_NEEDED_FROM > 1 && FROM_DIRECTION)	   || (MAX_NEEDED_TO > 1 && !FROM_DIRECTION))	  && __builtin_expect (consume_incomplete, 0)	  && status == __GCONV_INCOMPLETE_INPUT)	{# ifdef STORE_REST	  mbstate_t *state = data->__statep;	  STORE_REST# else	  size_t cnt;	  /* Make sure the remaining bytes fit into the state objects             buffer.  */	  assert (inend - *inptrp < 4);	  for (cnt = 0; *inptrp < inend; ++cnt)	    data->__statep->__value.__wchb[cnt] = *(*inptrp)++;	  data->__statep->__count &= ~7;	  data->__statep->__count |= cnt;# endif	}#endif    }  return status;}