FSOP_BASIC

struct _IO_FILE_plus
{
  FILE file;
  const struct _IO_jump_t *vtable;
};

#define _IO_MAGIC         0xFBAD0000 /* Magic number */
#define _IO_MAGIC_MASK    0xFFFF0000
#define _IO_USER_BUF          0x0001 /* Don't deallocate buffer on close. */
#define _IO_UNBUFFERED        0x0002
#define _IO_NO_READS          0x0004 /* Reading not allowed.  */
#define _IO_NO_WRITES         0x0008 /* Writing not allowed.  */
#define _IO_EOF_SEEN          0x0010
#define _IO_ERR_SEEN          0x0020
#define _IO_DELETE_DONT_CLOSE 0x0040 /* Don't call close(_fileno) on close.  */
#define _IO_LINKED            0x0080 /* In the list of all open files.  */
#define _IO_IN_BACKUP         0x0100
#define _IO_LINE_BUF          0x0200
#define _IO_TIED_PUT_GET      0x0400 /* Put and get pointer move in unison.  */
#define _IO_CURRENTLY_PUTTING 0x0800
#define _IO_IS_APPENDING      0x1000
#define _IO_IS_FILEBUF        0x2000 /* 0x4000  No longer used, reserved for compat.  */
#define _IO_USER_LOCK         0x8000

struct _IO_jump_t
{
    JUMP_FIELD(size_t, __dummy);
    JUMP_FIELD(size_t, __dummy2);
    JUMP_FIELD(_IO_finish_t, __finish);
    JUMP_FIELD(_IO_overflow_t, __overflow);
    JUMP_FIELD(_IO_underflow_t, __underflow);
    JUMP_FIELD(_IO_underflow_t, __uflow);
    JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
    /* showmany */
    JUMP_FIELD(_IO_xsputn_t, __xsputn);
    JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
    JUMP_FIELD(_IO_seekoff_t, __seekoff);
    JUMP_FIELD(_IO_seekpos_t, __seekpos);
    JUMP_FIELD(_IO_setbuf_t, __setbuf);
    JUMP_FIELD(_IO_sync_t, __sync);
    JUMP_FIELD(_IO_doallocate_t, __doallocate);
    JUMP_FIELD(_IO_read_t, __read);
    JUMP_FIELD(_IO_write_t, __write);
    JUMP_FIELD(_IO_seek_t, __seek);
    JUMP_FIELD(_IO_close_t, __close);
    JUMP_FIELD(_IO_stat_t, __stat);
    JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
    JUMP_FIELD(_IO_imbue_t, __imbue);
};

#include "libioP.h"
#include <string.h>
#include <limits.h>
int
_IO_puts (const char *str)
{
  int result = EOF;
  size_t len = strlen (str);
  _IO_acquire_lock (stdout);
  if ((_IO_vtable_offset (stdout) != 0
       || _IO_fwide (stdout, -1) == -1)
      && _IO_sputn (stdout, str, len) == len
      && _IO_putc_unlocked ('n', stdout) != EOF)
    result = MIN (INT_MAX, len + 1);
  _IO_release_lock (stdout);
  return result;
}
weak_alias (_IO_puts, puts)
libc_hidden_def (_IO_puts)

static inline const struct _IO_jump_t *
IO_validate_vtable (const struct _IO_jump_t *vtable)
{
  /* Fast path: The vtable pointer is within the __libc_IO_vtables
     section.  */
  uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
  uintptr_t ptr = (uintptr_t) vtable;
  uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;
  if (__glibc_unlikely (offset >= section_length))
    /* The vtable pointer is not in the expected section.  Use the
       slow path, which will terminate the process if necessary.  */
    _IO_vtable_check ();
  return vtable;
}

/* Extra data for wide character streams.  */  
struct _IO_wide_data  
{  
  wchar_t *_IO_read_ptr;  
  wchar_t *_IO_read_end;  
  wchar_t *_IO_read_base;  
  wchar_t *_IO_write_base; // 0x18  
  wchar_t *_IO_write_ptr;  
  wchar_t *_IO_write_end;  
  wchar_t *_IO_buf_base; // 0x30  
  wchar_t *_IO_buf_end;   
  wchar_t *_IO_save_base;  
  wchar_t *_IO_backup_base;  
  wchar_t *_IO_save_end;  
  __mbstate_t _IO_state;  
  __mbstate_t _IO_last_state;  
  struct _IO_codecvt _codecvt;  
  wchar_t _shortbuf[1];  
  const struct _IO_jump_t *_wide_vtable; // 0xe0  
};

const struct _IO_jump_t _IO_wfile_jumps libio_vtable =
{
  JUMP_INIT_DUMMY,
  JUMP_INIT(finish, _IO_new_file_finish),
  JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
  JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow),
  JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
  JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
  JUMP_INIT(xsputn, _IO_wfile_xsputn),
  JUMP_INIT(xsgetn, _IO_file_xsgetn),
  JUMP_INIT(seekoff, _IO_wfile_seekoff),
  JUMP_INIT(seekpos, _IO_default_seekpos),
  JUMP_INIT(setbuf, _IO_new_file_setbuf),
  JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
  JUMP_INIT(doallocate, _IO_wfile_doallocate),
  JUMP_INIT(read, _IO_file_read),
  JUMP_INIT(write, _IO_new_file_write),
  JUMP_INIT(seek, _IO_file_seek),
  JUMP_INIT(close, _IO_file_close),
  JUMP_INIT(stat, _IO_file_stat),
  JUMP_INIT(showmanyc, _IO_default_showmanyc),
  JUMP_INIT(imbue, _IO_default_imbue)
};

int _IO_flush_all_lockp (int do_lock)  
{  
  int result = 0;  
  FILE *fp;  
  
#ifdef _IO_MTSAFE_IO  
  _IO_cleanup_region_start_noarg (flush_cleanup);  
  _IO_lock_lock (list_all_lock);  
#endif  
  
  for (fp = (FILE *) _IO_list_all; fp != NULL; fp = fp->_chain)  
    {  
      run_fp = fp;  
      if (do_lock)  
    _IO_flockfile (fp);  
  
      if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)  
       || (_IO_vtable_offset (fp) == 0  
           && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr  
                    > fp->_wide_data->_IO_write_base))  
       )  
      && _IO_OVERFLOW (fp, EOF) == EOF) // <--- overflow call  
    result = EOF;  
  
      if (do_lock)  
    _IO_funlockfile (fp);  
      run_fp = NULL;  
    }  
  
#ifdef _IO_MTSAFE_IO  
  _IO_lock_unlock (list_all_lock);  
  _IO_cleanup_region_end (0);  
#endif  
  
  return result;  
}  
  
// definition of _IO_OVERFLOW  
typedef int (*_IO_overflow_t) (FILE *, int);  
#define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)  
#define _IO_WOVERFLOW(FP, CH) WJUMP1 (__overflow, FP, CH)