Getwchar stack smashing detected

#include <locale.h>
#include <wchar.h>
 
int main()
{
    setlocale(LC_ALL, "ru_RU.UTF-8");
 
    for (int i = 0; i < 10; i++) {
        if (WEOF == (getwchar()) ) break;
    }
 
    return 0;
}

int main()
{
 fgetc(stdin); /*сориентирует поток в "узкий", т.е. он будет однобайтным ASCII*/
return 0;}

int main()
{
 fgetwc(stdin); /*сориентирует поток в "широкий", т.е. он будет многобайтным Unicode*/
return 0;}

_IO_wfile_sync (FILE *fp)
{
  ssize_t delta;
  wint_t retval = 0;
  /*    char* ptr = cur_ptr(); */
  if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
    if (_IO_do_flush (fp))
      return WEOF;
  delta = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
  if (delta != 0)
    {
      /* We have to find out how many bytes we have to go back in the
         external buffer.  */
      struct _IO_codecvt *cv = fp->_codecvt;
      off64_t new_pos;
      int clen = (*cv->__codecvt_do_encoding) (cv);
      if (clen > 0)
        /* It is easy, a fixed number of input bytes are used for each
           wide character.  */
        delta *= clen;
      else
        {
          /* We have to find out the hard way how much to back off.
             To do this we determine how much input we needed to
             generate the wide characters up to the current reading
             position.  */
          int nread;
          fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
          nread = (*cv->__codecvt_do_length) (cv, &fp->_wide_data->_IO_state,
                                              fp->_IO_read_base,
                                              fp->_IO_read_end, delta);
          fp->_IO_read_ptr = fp->_IO_read_base + nread;
          delta = -(fp->_IO_read_end - fp->_IO_read_base - nread);
        }
      new_pos = _IO_SYSSEEK (fp, delta, 1);
      if (new_pos != (off64_t) EOF)
        {
          fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
          fp->_IO_read_end = fp->_IO_read_ptr;
        }
      else if (errno == ESPIPE)
        ; /* Ignore error from unseekable devices. */
      else
        retval = WEOF;
    }
  if (retval != WEOF)
    fp->_offset = _IO_pos_BAD;
  /* FIXME: Cleanup - can this be shared? */
  /*    setg(base(), ptr, ptr); */
  return retval;
}
libc_hidden_def (_IO_wfile_sync)

do_length (struct _IO_codecvt *codecvt, __mbstate_t *statep,
           const char *from_start, const char *from_end, size_t max)
{
  int result;
  const unsigned char *cp = (const unsigned char *) from_start;
  wchar_t to_buf[max];
  struct __gconv_step *gs = codecvt->__cd_in.__cd.__steps;
  size_t dummy;
  codecvt->__cd_in.__cd.__data[0].__outbuf = (unsigned char *) to_buf;
  codecvt->__cd_in.__cd.__data[0].__outbufend = (unsigned char *) &to_buf[max];
  codecvt->__cd_in.__cd.__data[0].__statep = statep;
  __gconv_fct fct = gs->__fct;
#ifdef PTR_DEMANGLE
  if (gs->__shlib_handle != NULL)
    PTR_DEMANGLE (fct);
#endif
  DL_CALL_FCT (fct,
               (gs, codecvt->__cd_in.__cd.__data, &cp,
                (const unsigned char *) from_end, NULL,
                &dummy, 0, 0));
  result = cp - (const unsigned char *) from_start;
  return result;
}

delta = fp->_wide_data->_IO_read_end - fp->_wide_data->_IO_read_ptr;

#include <string.h>
#include <errno.h>
#include <locale.h>
#include <stdio.h>
#include <wchar.h>
 
int main()
{
    
    setlocale(LC_ALL, "ru_RU.UTF-8"); /*а вот тут уже до лампочки 
        обращения setlocale к потоку stdin - он уже "широкий" и сегфолтов/стеков уже не будет*/
    printf("1. errno = %s\n", strerror(errno));
 
    for (int i = 0; i < 10; i++) {
        if (WEOF == (getwc(stdin))) break;
    }
 
    printf("2. errno = %s\n", strerror(errno));
    return 0;
}