#include "available-stubs.h"

#include <curses.h>
#include "checker_api.h"

/* /usr/include/curses.h:222:OC */ extern WINDOW *initscr32 (/* ??? */);
#ifdef HAVE_newterm32
/* From `/usr/include/curses.h:223'.  */
SCREEN * chkr_stub_newterm32 (char * arg0, FILE * arg1, FILE * arg2) __asm__ (CHKR_PREFIX ("newterm32"));
SCREEN *
chkr_stub_newterm32 (char * arg0, FILE * arg1, FILE * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (FILE), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (FILE), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (newterm32);
#else
  return newterm32 (arg0, arg1, arg2);
  {
    SCREEN * res;
    res = newterm32 (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_newterm32 */

#ifdef HAVE_m_initscr
/* From `/usr/include/curses.h:232'.  */
WINDOW * chkr_stub_m_initscr (void ) __asm__ (CHKR_PREFIX ("m_initscr"));
WINDOW *
chkr_stub_m_initscr (void )
{
#if USE_BI_JUMP
  __builtin_jump (m_initscr);
#else
  return m_initscr ();
  {
    WINDOW * res;
    res = m_initscr ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_initscr */

#ifdef HAVE_m_newterm
/* From `/usr/include/curses.h:234'.  */
SCREEN * chkr_stub_m_newterm (char * arg0, FILE * arg1, FILE * arg2) __asm__ (CHKR_PREFIX ("m_newterm"));
SCREEN *
chkr_stub_m_newterm (char * arg0, FILE * arg1, FILE * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (FILE), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (FILE), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (m_newterm);
#else
  return m_newterm (arg0, arg1, arg2);
  {
    SCREEN * res;
    res = m_newterm (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_newterm */

#ifdef HAVE_m_addch
/* From `/usr/include/curses.h:236'.  */
int chkr_stub_m_addch (int arg0) __asm__ (CHKR_PREFIX ("m_addch"));
int
chkr_stub_m_addch (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (m_addch);
#else
  return m_addch (arg0);
  {
    int res;
    res = m_addch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_addch */

#ifdef HAVE_m_addstr
/* From `/usr/include/curses.h:236'.  */
int chkr_stub_m_addstr (char * arg0) __asm__ (CHKR_PREFIX ("m_addstr"));
int
chkr_stub_m_addstr (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (m_addstr);
#else
  return m_addstr (arg0);
  {
    int res;
    res = m_addstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_addstr */

#ifdef HAVE_m_clear
/* From `/usr/include/curses.h:236'.  */
int chkr_stub_m_clear (void ) __asm__ (CHKR_PREFIX ("m_clear"));
int
chkr_stub_m_clear (void )
{
#if USE_BI_JUMP
  __builtin_jump (m_clear);
#else
  return m_clear ();
  {
    int res;
    res = m_clear ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_clear */

#ifdef HAVE_m_erase
/* From `/usr/include/curses.h:236'.  */
int chkr_stub_m_erase (void ) __asm__ (CHKR_PREFIX ("m_erase"));
int
chkr_stub_m_erase (void )
{
#if USE_BI_JUMP
  __builtin_jump (m_erase);
#else
  return m_erase ();
  {
    int res;
    res = m_erase ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_erase */

#ifdef HAVE_m_move
/* From `/usr/include/curses.h:237'.  */
int chkr_stub_m_move (int arg0, int arg1) __asm__ (CHKR_PREFIX ("m_move"));
int
chkr_stub_m_move (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (m_move);
#else
  return m_move (arg0, arg1);
  {
    int res;
    res = m_move (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_move */

#ifdef HAVE_m_refresh
/* From `/usr/include/curses.h:237'.  */
int chkr_stub_m_refresh (void ) __asm__ (CHKR_PREFIX ("m_refresh"));
int
chkr_stub_m_refresh (void )
{
#if USE_BI_JUMP
  __builtin_jump (m_refresh);
#else
  return m_refresh ();
  {
    int res;
    res = m_refresh ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_m_refresh */

#ifdef HAVE_newscreen
/* From `/usr/include/curses.h:257'.  */
SCREEN * chkr_stub_newscreen (char * arg0, int arg1, int arg2, int arg3, FILE * arg4, FILE * arg5) __asm__ (CHKR_PREFIX ("newscreen"));
SCREEN *
chkr_stub_newscreen (char * arg0, int arg1, int arg2, int arg3, FILE * arg4, FILE * arg5)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg4, sizeof (FILE), CHKR_XX, "arg4");
  stubs_chkr_check_addr (arg5, sizeof (FILE), CHKR_XX, "arg5");
#if USE_BI_JUMP
  __builtin_jump (newscreen);
#else
  return newscreen (arg0, arg1, arg2, arg3, arg4, arg5);
  {
    SCREEN * res;
    res = newscreen (arg0, arg1, arg2, arg3, arg4, arg5);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_newscreen */

#ifdef HAVE_setcurscreen
/* From `/usr/include/curses.h:258'.  */
SCREEN * chkr_stub_setcurscreen (SCREEN * arg0) __asm__ (CHKR_PREFIX ("setcurscreen"));
SCREEN *
chkr_stub_setcurscreen (SCREEN * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (SCREEN), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (setcurscreen);
#else
  return setcurscreen (arg0);
  {
    SCREEN * res;
    res = setcurscreen (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_setcurscreen */

#ifdef HAVE_initscr32
/* From `/usr/include/curses.h:260'.  */
WINDOW * chkr_stub_initscr32 (void ) __asm__ (CHKR_PREFIX ("initscr32"));
WINDOW *
chkr_stub_initscr32 (void )
{
#if USE_BI_JUMP
  __builtin_jump (initscr32);
#else
  return initscr32 ();
  {
    WINDOW * res;
    res = initscr32 ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_initscr32 */

#ifdef HAVE_newwin
/* From `/usr/include/curses.h:261'.  */
WINDOW * chkr_stub_newwin (int arg0, int arg1, int arg2, int arg3) __asm__ (CHKR_PREFIX ("newwin"));
WINDOW *
chkr_stub_newwin (int arg0, int arg1, int arg2, int arg3)
{
#if USE_BI_JUMP
  __builtin_jump (newwin);
#else
  return newwin (arg0, arg1, arg2, arg3);
  {
    WINDOW * res;
    res = newwin (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_newwin */

#ifdef HAVE_newpad
/* From `/usr/include/curses.h:262'.  */
WINDOW * chkr_stub_newpad (int arg0, int arg1) __asm__ (CHKR_PREFIX ("newpad"));
WINDOW *
chkr_stub_newpad (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (newpad);
#else
  return newpad (arg0, arg1);
  {
    WINDOW * res;
    res = newpad (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_newpad */

#ifdef HAVE_derwin
/* From `/usr/include/curses.h:263'.  */
WINDOW * chkr_stub_derwin (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4) __asm__ (CHKR_PREFIX ("derwin"));
WINDOW *
chkr_stub_derwin (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (derwin);
#else
  return derwin (arg0, arg1, arg2, arg3, arg4);
  {
    WINDOW * res;
    res = derwin (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_derwin */

#ifdef HAVE_dupwin
/* From `/usr/include/curses.h:264'.  */
WINDOW * chkr_stub_dupwin (WINDOW * arg0) __asm__ (CHKR_PREFIX ("dupwin"));
WINDOW *
chkr_stub_dupwin (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (dupwin);
#else
  return dupwin (arg0);
  {
    WINDOW * res;
    res = dupwin (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_dupwin */

#ifdef HAVE_getwin
/* From `/usr/include/curses.h:265'.  */
WINDOW * chkr_stub_getwin (FILE * arg0) __asm__ (CHKR_PREFIX ("getwin"));
WINDOW *
chkr_stub_getwin (FILE * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (FILE), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getwin);
#else
  return getwin (arg0);
  {
    WINDOW * res;
    res = getwin (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getwin */

#ifdef HAVE_wgetch
/* From `/usr/include/curses.h:267'.  */
int chkr_stub_wgetch (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wgetch"));
int
chkr_stub_wgetch (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wgetch);
#else
  return wgetch (arg0);
  {
    int res;
    res = wgetch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wgetch */

#ifdef HAVE_longname
/* From `/usr/include/curses.h:269'.  */
char * chkr_stub_longname (void ) __asm__ (CHKR_PREFIX ("longname"));
char *
chkr_stub_longname (void )
{
#if USE_BI_JUMP
  __builtin_jump (longname);
#else
  return longname ();
  {
    char * res;
    res = longname ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_longname */

#ifdef HAVE_termname
/* From `/usr/include/curses.h:270'.  */
char * chkr_stub_termname (void ) __asm__ (CHKR_PREFIX ("termname"));
char *
chkr_stub_termname (void )
{
#if USE_BI_JUMP
  __builtin_jump (termname);
#else
  return termname ();
  {
    char * res;
    res = termname ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_termname */

#ifdef HAVE_keyname
/* From `/usr/include/curses.h:271'.  */
char * chkr_stub_keyname (int arg0) __asm__ (CHKR_PREFIX ("keyname"));
char *
chkr_stub_keyname (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (keyname);
#else
  return keyname (arg0);
  {
    char * res;
    res = keyname (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_keyname */

#ifdef HAVE_slk_label
/* From `/usr/include/curses.h:272'.  */
char * chkr_stub_slk_label (int arg0) __asm__ (CHKR_PREFIX ("slk_label"));
char *
chkr_stub_slk_label (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (slk_label);
#else
  return slk_label (arg0);
  {
    char * res;
    res = slk_label (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_label */

#ifdef HAVE_erasechar
/* From `/usr/include/curses.h:273'.  */
char chkr_stub_erasechar (void ) __asm__ (CHKR_PREFIX ("erasechar"));
char
chkr_stub_erasechar (void )
{
#if USE_BI_JUMP
  __builtin_jump (erasechar);
#else
  return erasechar ();
  {
    char res;
    res = erasechar ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_erasechar */

#ifdef HAVE_killchar
/* From `/usr/include/curses.h:274'.  */
char chkr_stub_killchar (void ) __asm__ (CHKR_PREFIX ("killchar"));
char
chkr_stub_killchar (void )
{
#if USE_BI_JUMP
  __builtin_jump (killchar);
#else
  return killchar ();
  {
    char res;
    res = killchar ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_killchar */

#ifdef HAVE_unctrl
/* From `/usr/include/curses.h:275'.  */
char * chkr_stub_unctrl (int arg0) __asm__ (CHKR_PREFIX ("unctrl"));
char *
chkr_stub_unctrl (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (unctrl);
#else
  return unctrl (arg0);
  {
    char * res;
    res = unctrl (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_unctrl */

#ifdef HAVE_termattrs
/* From `/usr/include/curses.h:277'.  */
chtype chkr_stub_termattrs (void ) __asm__ (CHKR_PREFIX ("termattrs"));
chtype
chkr_stub_termattrs (void )
{
#if USE_BI_JUMP
  __builtin_jump (termattrs);
#else
  return termattrs ();
  {
    chtype res;
    res = termattrs ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_termattrs */

#ifdef HAVE_vidupdate
/* From `/usr/include/curses.h:279'.  */
void chkr_stub_vidupdate (chtype arg0, chtype arg1, int (*) (char) arg2) __asm__ (CHKR_PREFIX ("vidupdate"));
void
chkr_stub_vidupdate (chtype arg0, chtype arg1, int (*) (char) arg2)
{
#if USE_BI_JUMP
  __builtin_jump (vidupdate);
#else
  vidupdate (arg0, arg1, arg2);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_vidupdate */

#ifdef HAVE_wsyncup
/* From `/usr/include/curses.h:280'.  */
void chkr_stub_wsyncup (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wsyncup"));
void
chkr_stub_wsyncup (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wsyncup);
#else
  wsyncup (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wsyncup */

#ifdef HAVE_wsyncdown
/* From `/usr/include/curses.h:280'.  */
void chkr_stub_wsyncdown (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wsyncdown"));
void
chkr_stub_wsyncdown (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wsyncdown);
#else
  wsyncdown (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wsyncdown */

#ifdef HAVE_delscreen
/* From `/usr/include/curses.h:281'.  */
void chkr_stub_delscreen (SCREEN * arg0) __asm__ (CHKR_PREFIX ("delscreen"));
void
chkr_stub_delscreen (SCREEN * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (SCREEN), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (delscreen);
#else
  delscreen (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_delscreen */

#ifdef HAVE_curserr
/* From `/usr/include/curses.h:281'.  */
void chkr_stub_curserr (void ) __asm__ (CHKR_PREFIX ("curserr"));
void
chkr_stub_curserr (void )
{
#if USE_BI_JUMP
  __builtin_jump (curserr);
#else
  curserr ();
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_curserr */

#ifdef HAVE__setqiflush
/* From `/usr/include/curses.h:282'.  */
void chkr_stub__setqiflush (int arg0) __asm__ (CHKR_PREFIX ("_setqiflush"));
void
chkr_stub__setqiflush (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (_setqiflush);
#else
  _setqiflush (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE__setqiflush */

#ifdef HAVE_wcursyncup
/* From `/usr/include/curses.h:283'.  */
void chkr_stub_wcursyncup (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wcursyncup"));
void
chkr_stub_wcursyncup (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wcursyncup);
#else
  wcursyncup (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wcursyncup */

#ifdef HAVE_cbreak
/* From `/usr/include/curses.h:285'.  */
int chkr_stub_cbreak (void ) __asm__ (CHKR_PREFIX ("cbreak"));
int
chkr_stub_cbreak (void )
{
#if USE_BI_JUMP
  __builtin_jump (cbreak);
#else
  return cbreak ();
  {
    int res;
    res = cbreak ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_cbreak */

#ifdef HAVE_nocbreak
/* From `/usr/include/curses.h:285'.  */
int chkr_stub_nocbreak (void ) __asm__ (CHKR_PREFIX ("nocbreak"));
int
chkr_stub_nocbreak (void )
{
#if USE_BI_JUMP
  __builtin_jump (nocbreak);
#else
  return nocbreak ();
  {
    int res;
    res = nocbreak ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_nocbreak */

#ifdef HAVE_reset_prog_mode
/* From `/usr/include/curses.h:286'.  */
int chkr_stub_reset_prog_mode (void ) __asm__ (CHKR_PREFIX ("reset_prog_mode"));
int
chkr_stub_reset_prog_mode (void )
{
#if USE_BI_JUMP
  __builtin_jump (reset_prog_mode);
#else
  return reset_prog_mode ();
  {
    int res;
    res = reset_prog_mode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_reset_prog_mode */

#ifdef HAVE_reset_shell_mode
/* From `/usr/include/curses.h:286'.  */
int chkr_stub_reset_shell_mode (void ) __asm__ (CHKR_PREFIX ("reset_shell_mode"));
int
chkr_stub_reset_shell_mode (void )
{
#if USE_BI_JUMP
  __builtin_jump (reset_shell_mode);
#else
  return reset_shell_mode ();
  {
    int res;
    res = reset_shell_mode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_reset_shell_mode */

#ifdef HAVE_def_prog_mode
/* From `/usr/include/curses.h:287'.  */
int chkr_stub_def_prog_mode (void ) __asm__ (CHKR_PREFIX ("def_prog_mode"));
int
chkr_stub_def_prog_mode (void )
{
#if USE_BI_JUMP
  __builtin_jump (def_prog_mode);
#else
  return def_prog_mode ();
  {
    int res;
    res = def_prog_mode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_def_prog_mode */

#ifdef HAVE__setecho
/* From `/usr/include/curses.h:287'.  */
int chkr_stub__setecho (int arg0) __asm__ (CHKR_PREFIX ("_setecho"));
int
chkr_stub__setecho (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (_setecho);
#else
  return _setecho (arg0);
  {
    int res;
    res = _setecho (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE__setecho */

#ifdef HAVE__setnonl
/* From `/usr/include/curses.h:287'.  */
int chkr_stub__setnonl (int arg0) __asm__ (CHKR_PREFIX ("_setnonl"));
int
chkr_stub__setnonl (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (_setnonl);
#else
  return _setnonl (arg0);
  {
    int res;
    res = _setnonl (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE__setnonl */

#ifdef HAVE_def_shell_mode
/* From `/usr/include/curses.h:288'.  */
int chkr_stub_def_shell_mode (void ) __asm__ (CHKR_PREFIX ("def_shell_mode"));
int
chkr_stub_def_shell_mode (void )
{
#if USE_BI_JUMP
  __builtin_jump (def_shell_mode);
#else
  return def_shell_mode ();
  {
    int res;
    res = def_shell_mode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_def_shell_mode */

#ifdef HAVE_raw
/* From `/usr/include/curses.h:288'.  */
int chkr_stub_raw (void ) __asm__ (CHKR_PREFIX ("raw"));
int
chkr_stub_raw (void )
{
#if USE_BI_JUMP
  __builtin_jump (raw);
#else
  return raw ();
  {
    int res;
    res = raw ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_raw */

#ifdef HAVE_savetty
/* From `/usr/include/curses.h:289'.  */
int chkr_stub_savetty (void ) __asm__ (CHKR_PREFIX ("savetty"));
int
chkr_stub_savetty (void )
{
#if USE_BI_JUMP
  __builtin_jump (savetty);
#else
  return savetty ();
  {
    int res;
    res = savetty ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_savetty */

#ifdef HAVE_traceon
/* From `/usr/include/curses.h:289'.  */
int chkr_stub_traceon (void ) __asm__ (CHKR_PREFIX ("traceon"));
int
chkr_stub_traceon (void )
{
#if USE_BI_JUMP
  __builtin_jump (traceon);
#else
  return traceon ();
  {
    int res;
    res = traceon ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_traceon */

#ifdef HAVE__meta
/* From `/usr/include/curses.h:289'.  */
int chkr_stub__meta (int arg0) __asm__ (CHKR_PREFIX ("_meta"));
int
chkr_stub__meta (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (_meta);
#else
  return _meta (arg0);
  {
    int res;
    res = _meta (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE__meta */

#ifdef HAVE_traceoff
/* From `/usr/include/curses.h:290'.  */
int chkr_stub_traceoff (void ) __asm__ (CHKR_PREFIX ("traceoff"));
int
chkr_stub_traceoff (void )
{
#if USE_BI_JUMP
  __builtin_jump (traceoff);
#else
  return traceoff ();
  {
    int res;
    res = traceoff ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_traceoff */

#ifdef HAVE_noraw
/* From `/usr/include/curses.h:290'.  */
int chkr_stub_noraw (void ) __asm__ (CHKR_PREFIX ("noraw"));
int
chkr_stub_noraw (void )
{
#if USE_BI_JUMP
  __builtin_jump (noraw);
#else
  return noraw ();
  {
    int res;
    res = noraw ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_noraw */

#ifdef HAVE_flushinp
/* From `/usr/include/curses.h:290'.  */
int chkr_stub_flushinp (void ) __asm__ (CHKR_PREFIX ("flushinp"));
int
chkr_stub_flushinp (void )
{
#if USE_BI_JUMP
  __builtin_jump (flushinp);
#else
  return flushinp ();
  {
    int res;
    res = flushinp ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_flushinp */

#ifdef HAVE__getsyx
/* From `/usr/include/curses.h:291'.  */
int chkr_stub__getsyx (int * arg0, int * arg1) __asm__ (CHKR_PREFIX ("_getsyx"));
int
chkr_stub__getsyx (int * arg0, int * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (int), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (int), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (_getsyx);
#else
  return _getsyx (arg0, arg1);
  {
    int res;
    res = _getsyx (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE__getsyx */

#ifdef HAVE__ring
/* From `/usr/include/curses.h:292'.  */
int chkr_stub__ring (int arg0) __asm__ (CHKR_PREFIX ("_ring"));
int
chkr_stub__ring (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (_ring);
#else
  return _ring (arg0);
  {
    int res;
    res = _ring (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE__ring */

#ifdef HAVE_resetty
/* From `/usr/include/curses.h:292'.  */
int chkr_stub_resetty (void ) __asm__ (CHKR_PREFIX ("resetty"));
int
chkr_stub_resetty (void )
{
#if USE_BI_JUMP
  __builtin_jump (resetty);
#else
  return resetty ();
  {
    int res;
    res = resetty ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_resetty */

#ifdef HAVE_ripoffline
/* From `/usr/include/curses.h:293'.  */
int chkr_stub_ripoffline (int arg0, int (*) (WINDOW *, int) arg1) __asm__ (CHKR_PREFIX ("ripoffline"));
int
chkr_stub_ripoffline (int arg0, int (*) (WINDOW *, int) arg1)
{
#if USE_BI_JUMP
  __builtin_jump (ripoffline);
#else
  return ripoffline (arg0, arg1);
  {
    int res;
    res = ripoffline (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_ripoffline */

#ifdef HAVE_setsyx
/* From `/usr/include/curses.h:294'.  */
int chkr_stub_setsyx (int arg0, int arg1) __asm__ (CHKR_PREFIX ("setsyx"));
int
chkr_stub_setsyx (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (setsyx);
#else
  return setsyx (arg0, arg1);
  {
    int res;
    res = setsyx (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_setsyx */

#ifdef HAVE_slk_refresh
/* From `/usr/include/curses.h:294'.  */
int chkr_stub_slk_refresh (void ) __asm__ (CHKR_PREFIX ("slk_refresh"));
int
chkr_stub_slk_refresh (void )
{
#if USE_BI_JUMP
  __builtin_jump (slk_refresh);
#else
  return slk_refresh ();
  {
    int res;
    res = slk_refresh ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_refresh */

#ifdef HAVE_slk_restore
/* From `/usr/include/curses.h:295'.  */
int chkr_stub_slk_restore (void ) __asm__ (CHKR_PREFIX ("slk_restore"));
int
chkr_stub_slk_restore (void )
{
#if USE_BI_JUMP
  __builtin_jump (slk_restore);
#else
  return slk_restore ();
  {
    int res;
    res = slk_restore ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_restore */

#ifdef HAVE_wstandend
/* From `/usr/include/curses.h:296'.  */
int chkr_stub_wstandend (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wstandend"));
int
chkr_stub_wstandend (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wstandend);
#else
  return wstandend (arg0);
  {
    int res;
    res = wstandend (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wstandend */

#ifdef HAVE_wstandout
/* From `/usr/include/curses.h:296'.  */
int chkr_stub_wstandout (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wstandout"));
int
chkr_stub_wstandout (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wstandout);
#else
  return wstandout (arg0);
  {
    int res;
    res = wstandout (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wstandout */

#ifdef HAVE_w32attroff
/* From `/usr/include/curses.h:297'.  */
int chkr_stub_w32attroff (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("w32attroff"));
int
chkr_stub_w32attroff (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (w32attroff);
#else
  return w32attroff (arg0, arg1);
  {
    int res;
    res = w32attroff (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_w32attroff */

#ifdef HAVE_w32attron
/* From `/usr/include/curses.h:297'.  */
int chkr_stub_w32attron (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("w32attron"));
int
chkr_stub_w32attron (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (w32attron);
#else
  return w32attron (arg0, arg1);
  {
    int res;
    res = w32attron (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_w32attron */

#ifdef HAVE_w32attrset
/* From `/usr/include/curses.h:298'.  */
int chkr_stub_w32attrset (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("w32attrset"));
int
chkr_stub_w32attrset (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (w32attrset);
#else
  return w32attrset (arg0, arg1);
  {
    int res;
    res = w32attrset (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_w32attrset */

#ifdef HAVE_wrefresh
/* From `/usr/include/curses.h:299'.  */
int chkr_stub_wrefresh (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wrefresh"));
int
chkr_stub_wrefresh (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wrefresh);
#else
  return wrefresh (arg0);
  {
    int res;
    res = wrefresh (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wrefresh */

#ifdef HAVE_copywin
/* From `/usr/include/curses.h:301'.  */
int chkr_stub_copywin (WINDOW * arg0, WINDOW * arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8) __asm__ (CHKR_PREFIX ("copywin"));
int
chkr_stub_copywin (WINDOW * arg0, WINDOW * arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (WINDOW), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (copywin);
#else
  return copywin (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  {
    int res;
    res = copywin (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_copywin */

#ifdef HAVE_curs_set
/* From `/usr/include/curses.h:302'.  */
int chkr_stub_curs_set (int arg0) __asm__ (CHKR_PREFIX ("curs_set"));
int
chkr_stub_curs_set (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (curs_set);
#else
  return curs_set (arg0);
  {
    int res;
    res = curs_set (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_curs_set */

#ifdef HAVE_delay_output
/* From `/usr/include/curses.h:302'.  */
int chkr_stub_delay_output (int arg0) __asm__ (CHKR_PREFIX ("delay_output"));
int
chkr_stub_delay_output (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (delay_output);
#else
  return delay_output (arg0);
  {
    int res;
    res = delay_output (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_delay_output */

#ifdef HAVE_delwin
/* From `/usr/include/curses.h:302'.  */
int chkr_stub_delwin (WINDOW * arg0) __asm__ (CHKR_PREFIX ("delwin"));
int
chkr_stub_delwin (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (delwin);
#else
  return delwin (arg0);
  {
    int res;
    res = delwin (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_delwin */

#ifdef HAVE_doupdate
/* From `/usr/include/curses.h:303'.  */
int chkr_stub_doupdate (void ) __asm__ (CHKR_PREFIX ("doupdate"));
int
chkr_stub_doupdate (void )
{
#if USE_BI_JUMP
  __builtin_jump (doupdate);
#else
  return doupdate ();
  {
    int res;
    res = doupdate ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_doupdate */

#ifdef HAVE_drainio
/* From `/usr/include/curses.h:303'.  */
int chkr_stub_drainio (int arg0) __asm__ (CHKR_PREFIX ("drainio"));
int
chkr_stub_drainio (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (drainio);
#else
  return drainio (arg0);
  {
    int res;
    res = drainio (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_drainio */

#ifdef HAVE_endwin
/* From `/usr/include/curses.h:303'.  */
int chkr_stub_endwin (void ) __asm__ (CHKR_PREFIX ("endwin"));
int
chkr_stub_endwin (void )
{
#if USE_BI_JUMP
  __builtin_jump (endwin);
#else
  return endwin ();
  {
    int res;
    res = endwin ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_endwin */

#ifdef HAVE_isendwin
/* From `/usr/include/curses.h:303'.  */
int chkr_stub_isendwin (void ) __asm__ (CHKR_PREFIX ("isendwin"));
int
chkr_stub_isendwin (void )
{
#if USE_BI_JUMP
  __builtin_jump (isendwin);
#else
  return isendwin ();
  {
    int res;
    res = isendwin ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_isendwin */

#ifdef HAVE_baudrate
/* From `/usr/include/curses.h:304'.  */
int chkr_stub_baudrate (void ) __asm__ (CHKR_PREFIX ("baudrate"));
int
chkr_stub_baudrate (void )
{
#if USE_BI_JUMP
  __builtin_jump (baudrate);
#else
  return baudrate ();
  {
    int res;
    res = baudrate ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_baudrate */

#ifdef HAVE_has_ic
/* From `/usr/include/curses.h:304'.  */
int chkr_stub_has_ic (void ) __asm__ (CHKR_PREFIX ("has_ic"));
int
chkr_stub_has_ic (void )
{
#if USE_BI_JUMP
  __builtin_jump (has_ic);
#else
  return has_ic ();
  {
    int res;
    res = has_ic ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_has_ic */

#ifdef HAVE_has_il
/* From `/usr/include/curses.h:304'.  */
int chkr_stub_has_il (void ) __asm__ (CHKR_PREFIX ("has_il"));
int
chkr_stub_has_il (void )
{
#if USE_BI_JUMP
  __builtin_jump (has_il);
#else
  return has_il ();
  {
    int res;
    res = has_il ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_has_il */

#ifdef HAVE_keypad
/* From `/usr/include/curses.h:305'.  */
int chkr_stub_keypad (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("keypad"));
int
chkr_stub_keypad (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (keypad);
#else
  return keypad (arg0, arg1);
  {
    int res;
    res = keypad (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_keypad */

#ifdef HAVE_mvcur
/* From `/usr/include/curses.h:306'.  */
int chkr_stub_mvcur (int arg0, int arg1, int arg2, int arg3) __asm__ (CHKR_PREFIX ("mvcur"));
int
chkr_stub_mvcur (int arg0, int arg1, int arg2, int arg3)
{
#if USE_BI_JUMP
  __builtin_jump (mvcur);
#else
  return mvcur (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvcur (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvcur */

#ifdef HAVE_mvprintw
/* From `/usr/include/curses.h:308'.  */
int chkr_stub_mvprintw (int arg0, int arg1, ... ) __asm__ (CHKR_PREFIX ("mvprintw"));
int
chkr_stub_mvprintw (int arg0, int arg1, ... )
{
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (mvprintw);
#else
  return mvprintw (arg0, arg1, );
  {
    int res;
    res = mvprintw (arg0, arg1, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvprintw */

#ifdef HAVE_mvscanw
/* From `/usr/include/curses.h:308'.  */
int chkr_stub_mvscanw (int arg0, int arg1, ... ) __asm__ (CHKR_PREFIX ("mvscanw"));
int
chkr_stub_mvscanw (int arg0, int arg1, ... )
{
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (mvscanw);
#else
  return mvscanw (arg0, arg1, );
  {
    int res;
    res = mvscanw (arg0, arg1, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvscanw */

#ifdef HAVE_mvwprintw
/* From `/usr/include/curses.h:309'.  */
int chkr_stub_mvwprintw (WINDOW * arg0, int arg1, int arg2, ... ) __asm__ (CHKR_PREFIX ("mvwprintw"));
int
chkr_stub_mvwprintw (WINDOW * arg0, int arg1, int arg2, ... )
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (mvwprintw);
#else
  return mvwprintw (arg0, arg1, arg2, );
  {
    int res;
    res = mvwprintw (arg0, arg1, arg2, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwprintw */

#ifdef HAVE_mvwscanw
/* From `/usr/include/curses.h:310'.  */
int chkr_stub_mvwscanw (WINDOW * arg0, int arg1, int arg2, ... ) __asm__ (CHKR_PREFIX ("mvwscanw"));
int
chkr_stub_mvwscanw (WINDOW * arg0, int arg1, int arg2, ... )
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (mvwscanw);
#else
  return mvwscanw (arg0, arg1, arg2, );
  {
    int res;
    res = mvwscanw (arg0, arg1, arg2, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwscanw */

#ifdef HAVE_printw
/* From `/usr/include/curses.h:311'.  */
int chkr_stub_printw (char * arg0, ... ) __asm__ (CHKR_PREFIX ("printw"));
int
chkr_stub_printw (char * arg0, ... )
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (printw);
#else
  return printw (arg0, );
  {
    int res;
    res = printw (arg0, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_printw */

#ifdef HAVE_scanw
/* From `/usr/include/curses.h:311'.  */
int chkr_stub_scanw (char * arg0, ... ) __asm__ (CHKR_PREFIX ("scanw"));
int
chkr_stub_scanw (char * arg0, ... )
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (scanw);
#else
  return scanw (arg0, );
  {
    int res;
    res = scanw (arg0, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scanw */

#ifdef HAVE_wprintw
/* From `/usr/include/curses.h:312'.  */
int chkr_stub_wprintw (WINDOW * arg0, ... ) __asm__ (CHKR_PREFIX ("wprintw"));
int
chkr_stub_wprintw (WINDOW * arg0, ... )
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (wprintw);
#else
  return wprintw (arg0, );
  {
    int res;
    res = wprintw (arg0, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wprintw */

#ifdef HAVE_wscanw
/* From `/usr/include/curses.h:312'.  */
int chkr_stub_wscanw (WINDOW * arg0, ... ) __asm__ (CHKR_PREFIX ("wscanw"));
int
chkr_stub_wscanw (WINDOW * arg0, ... )
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  /* This function must be handled by the user */
#if USE_BI_JUMP
  __builtin_jump (wscanw);
#else
  return wscanw (arg0, );
  {
    int res;
    res = wscanw (arg0, );
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wscanw */

#ifdef HAVE_vwprintw
/* From `/usr/include/curses.h:319'.  */
int chkr_stub_vwprintw (WINDOW * arg0, char * arg1, void * arg2) __asm__ (CHKR_PREFIX ("vwprintw"));
int
chkr_stub_vwprintw (WINDOW * arg0, char * arg1, void * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (void), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (vwprintw);
#else
  return vwprintw (arg0, arg1, arg2);
  {
    int res;
    res = vwprintw (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_vwprintw */

#ifdef HAVE_vwscanw
/* From `/usr/include/curses.h:320'.  */
int chkr_stub_vwscanw (WINDOW * arg0, char * arg1, void * arg2) __asm__ (CHKR_PREFIX ("vwscanw"));
int
chkr_stub_vwscanw (WINDOW * arg0, char * arg1, void * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (void), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (vwscanw);
#else
  return vwscanw (arg0, arg1, arg2);
  {
    int res;
    res = vwscanw (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_vwscanw */

#ifdef HAVE_mvwin
/* From `/usr/include/curses.h:322'.  */
int chkr_stub_mvwin (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("mvwin"));
int
chkr_stub_mvwin (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwin);
#else
  return mvwin (arg0, arg1, arg2);
  {
    int res;
    res = mvwin (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwin */

#ifdef HAVE_mvderwin
/* From `/usr/include/curses.h:322'.  */
int chkr_stub_mvderwin (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("mvderwin"));
int
chkr_stub_mvderwin (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvderwin);
#else
  return mvderwin (arg0, arg1, arg2);
  {
    int res;
    res = mvderwin (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvderwin */

#ifdef HAVE_napms
/* From `/usr/include/curses.h:323'.  */
int chkr_stub_napms (int arg0) __asm__ (CHKR_PREFIX ("napms"));
int
chkr_stub_napms (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (napms);
#else
  return napms (arg0);
  {
    int res;
    res = napms (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_napms */

#ifdef HAVE_newkey
/* From `/usr/include/curses.h:323'.  */
int chkr_stub_newkey (char * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("newkey"));
int
chkr_stub_newkey (char * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (newkey);
#else
  return newkey (arg0, arg1, arg2);
  {
    int res;
    res = newkey (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_newkey */

#ifdef HAVE_filter
/* From `/usr/include/curses.h:324'.  */
int chkr_stub_filter (void ) __asm__ (CHKR_PREFIX ("filter"));
int
chkr_stub_filter (void )
{
#if USE_BI_JUMP
  __builtin_jump (filter);
#else
  return filter ();
  {
    int res;
    res = filter ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_filter */

#ifdef HAVE__overlay
/* From `/usr/include/curses.h:324'.  */
int chkr_stub__overlay (WINDOW * arg0, WINDOW * arg1, int arg2) __asm__ (CHKR_PREFIX ("_overlay"));
int
chkr_stub__overlay (WINDOW * arg0, WINDOW * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (WINDOW), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (_overlay);
#else
  return _overlay (arg0, arg1, arg2);
  {
    int res;
    res = _overlay (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE__overlay */

#ifdef HAVE_p32echochar
/* From `/usr/include/curses.h:325'.  */
int chkr_stub_p32echochar (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("p32echochar"));
int
chkr_stub_p32echochar (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (p32echochar);
#else
  return p32echochar (arg0, arg1);
  {
    int res;
    res = p32echochar (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_p32echochar */

#ifdef HAVE_pnoutrefresh
/* From `/usr/include/curses.h:326'.  */
int chkr_stub_pnoutrefresh (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6) __asm__ (CHKR_PREFIX ("pnoutrefresh"));
int
chkr_stub_pnoutrefresh (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (pnoutrefresh);
#else
  return pnoutrefresh (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
  {
    int res;
    res = pnoutrefresh (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_pnoutrefresh */

#ifdef HAVE_prefresh
/* From `/usr/include/curses.h:327'.  */
int chkr_stub_prefresh (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6) __asm__ (CHKR_PREFIX ("prefresh"));
int
chkr_stub_prefresh (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (prefresh);
#else
  return prefresh (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
  {
    int res;
    res = prefresh (arg0, arg1, arg2, arg3, arg4, arg5, arg6);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_prefresh */

#ifdef HAVE_putwin
/* From `/usr/include/curses.h:329'.  */
int chkr_stub_putwin (WINDOW * arg0, FILE * arg1) __asm__ (CHKR_PREFIX ("putwin"));
int
chkr_stub_putwin (WINDOW * arg0, FILE * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (FILE), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (putwin);
#else
  return putwin (arg0, arg1);
  {
    int res;
    res = putwin (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_putwin */

#ifdef HAVE_wredrawln
/* From `/usr/include/curses.h:329'.  */
int chkr_stub_wredrawln (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("wredrawln"));
int
chkr_stub_wredrawln (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wredrawln);
#else
  return wredrawln (arg0, arg1, arg2);
  {
    int res;
    res = wredrawln (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wredrawln */

#ifdef HAVE_scr_dump
/* From `/usr/include/curses.h:330'.  */
int chkr_stub_scr_dump (char * arg0) __asm__ (CHKR_PREFIX ("scr_dump"));
int
chkr_stub_scr_dump (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (scr_dump);
#else
  return scr_dump (arg0);
  {
    int res;
    res = scr_dump (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scr_dump */

#ifdef HAVE_setupterm
/* From `/usr/include/curses.h:330'.  */
int chkr_stub_setupterm (char * arg0, int arg1, int * arg2) __asm__ (CHKR_PREFIX ("setupterm"));
int
chkr_stub_setupterm (char * arg0, int arg1, int * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg2, sizeof (int), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (setupterm);
#else
  return setupterm (arg0, arg1, arg2);
  {
    int res;
    res = setupterm (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_setupterm */

#ifdef HAVE_slk_attron
/* From `/usr/include/curses.h:332'.  */
int chkr_stub_slk_attron (chtype arg0) __asm__ (CHKR_PREFIX ("slk_attron"));
int
chkr_stub_slk_attron (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (slk_attron);
#else
  return slk_attron (arg0);
  {
    int res;
    res = slk_attron (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_attron */

#ifdef HAVE_slk_attroff
/* From `/usr/include/curses.h:332'.  */
int chkr_stub_slk_attroff (chtype arg0) __asm__ (CHKR_PREFIX ("slk_attroff"));
int
chkr_stub_slk_attroff (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (slk_attroff);
#else
  return slk_attroff (arg0);
  {
    int res;
    res = slk_attroff (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_attroff */

#ifdef HAVE_slk_attrset
/* From `/usr/include/curses.h:332'.  */
int chkr_stub_slk_attrset (chtype arg0) __asm__ (CHKR_PREFIX ("slk_attrset"));
int
chkr_stub_slk_attrset (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (slk_attrset);
#else
  return slk_attrset (arg0);
  {
    int res;
    res = slk_attrset (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_attrset */

#ifdef HAVE_slk_clear
/* From `/usr/include/curses.h:333'.  */
int chkr_stub_slk_clear (void ) __asm__ (CHKR_PREFIX ("slk_clear"));
int
chkr_stub_slk_clear (void )
{
#if USE_BI_JUMP
  __builtin_jump (slk_clear);
#else
  return slk_clear ();
  {
    int res;
    res = slk_clear ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_clear */

#ifdef HAVE_slk_noutrefresh
/* From `/usr/include/curses.h:333'.  */
int chkr_stub_slk_noutrefresh (void ) __asm__ (CHKR_PREFIX ("slk_noutrefresh"));
int
chkr_stub_slk_noutrefresh (void )
{
#if USE_BI_JUMP
  __builtin_jump (slk_noutrefresh);
#else
  return slk_noutrefresh ();
  {
    int res;
    res = slk_noutrefresh ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_noutrefresh */

#ifdef HAVE_slk_set
/* From `/usr/include/curses.h:334'.  */
int chkr_stub_slk_set (int arg0, char * arg1, int arg2) __asm__ (CHKR_PREFIX ("slk_set"));
int
chkr_stub_slk_set (int arg0, char * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (slk_set);
#else
  return slk_set (arg0, arg1, arg2);
  {
    int res;
    res = slk_set (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_set */

#ifdef HAVE_slk_start
/* From `/usr/include/curses.h:335'.  */
int chkr_stub_slk_start (int arg0, int * arg1) __asm__ (CHKR_PREFIX ("slk_start"));
int
chkr_stub_slk_start (int arg0, int * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg1, sizeof (int), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (slk_start);
#else
  return slk_start (arg0, arg1);
  {
    int res;
    res = slk_start (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_start */

#ifdef HAVE_slk_touch
/* From `/usr/include/curses.h:335'.  */
int chkr_stub_slk_touch (void ) __asm__ (CHKR_PREFIX ("slk_touch"));
int
chkr_stub_slk_touch (void )
{
#if USE_BI_JUMP
  __builtin_jump (slk_touch);
#else
  return slk_touch ();
  {
    int res;
    res = slk_touch ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_touch */

#ifdef HAVE_start_color
/* From `/usr/include/curses.h:335'.  */
int chkr_stub_start_color (void ) __asm__ (CHKR_PREFIX ("start_color"));
int
chkr_stub_start_color (void )
{
#if USE_BI_JUMP
  __builtin_jump (start_color);
#else
  return start_color ();
  {
    int res;
    res = start_color ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_start_color */

#ifdef HAVE_typeahead
/* From `/usr/include/curses.h:336'.  */
int chkr_stub_typeahead (int arg0) __asm__ (CHKR_PREFIX ("typeahead"));
int
chkr_stub_typeahead (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (typeahead);
#else
  return typeahead (arg0);
  {
    int res;
    res = typeahead (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_typeahead */

#ifdef HAVE_can_change_color
/* From `/usr/include/curses.h:338'.  */
bool chkr_stub_can_change_color (void ) __asm__ (CHKR_PREFIX ("can_change_color"));
bool
chkr_stub_can_change_color (void )
{
#if USE_BI_JUMP
  __builtin_jump (can_change_color);
#else
  return can_change_color ();
  {
    bool res;
    res = can_change_color ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_can_change_color */

#ifdef HAVE_has_colors
/* From `/usr/include/curses.h:338'.  */
bool chkr_stub_has_colors (void ) __asm__ (CHKR_PREFIX ("has_colors"));
bool
chkr_stub_has_colors (void )
{
#if USE_BI_JUMP
  __builtin_jump (has_colors);
#else
  return has_colors ();
  {
    bool res;
    res = has_colors ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_has_colors */

#ifdef HAVE_w32addch
/* From `/usr/include/curses.h:340'.  */
int chkr_stub_w32addch (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("w32addch"));
int
chkr_stub_w32addch (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (w32addch);
#else
  return w32addch (arg0, arg1);
  {
    int res;
    res = w32addch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_w32addch */

#ifdef HAVE_waddchnstr
/* From `/usr/include/curses.h:341'.  */
int chkr_stub_waddchnstr (WINDOW * arg0, chtype * arg1, int arg2) __asm__ (CHKR_PREFIX ("waddchnstr"));
int
chkr_stub_waddchnstr (WINDOW * arg0, chtype * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddchnstr);
#else
  return waddchnstr (arg0, arg1, arg2);
  {
    int res;
    res = waddchnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddchnstr */

#ifdef HAVE_waddnstr
/* From `/usr/include/curses.h:342'.  */
int chkr_stub_waddnstr (WINDOW * arg0, char * arg1, int arg2) __asm__ (CHKR_PREFIX ("waddnstr"));
int
chkr_stub_waddnstr (WINDOW * arg0, char * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddnstr);
#else
  return waddnstr (arg0, arg1, arg2);
  {
    int res;
    res = waddnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddnstr */

#ifdef HAVE_wbkgd
/* From `/usr/include/curses.h:343'.  */
int chkr_stub_wbkgd (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("wbkgd"));
int
chkr_stub_wbkgd (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wbkgd);
#else
  return wbkgd (arg0, arg1);
  {
    int res;
    res = wbkgd (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wbkgd */

#ifdef HAVE_wborder
/* From `/usr/include/curses.h:345'.  */
int chkr_stub_wborder (WINDOW * arg0, chtype arg1, chtype arg2, chtype arg3, chtype arg4, chtype arg5, chtype arg6, chtype arg7, chtype arg8) __asm__ (CHKR_PREFIX ("wborder"));
int
chkr_stub_wborder (WINDOW * arg0, chtype arg1, chtype arg2, chtype arg3, chtype arg4, chtype arg5, chtype arg6, chtype arg7, chtype arg8)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wborder);
#else
  return wborder (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
  {
    int res;
    res = wborder (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wborder */

#ifdef HAVE_wclrtobot
/* From `/usr/include/curses.h:346'.  */
int chkr_stub_wclrtobot (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wclrtobot"));
int
chkr_stub_wclrtobot (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wclrtobot);
#else
  return wclrtobot (arg0);
  {
    int res;
    res = wclrtobot (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wclrtobot */

#ifdef HAVE_wclrtoeol
/* From `/usr/include/curses.h:346'.  */
int chkr_stub_wclrtoeol (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wclrtoeol"));
int
chkr_stub_wclrtoeol (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wclrtoeol);
#else
  return wclrtoeol (arg0);
  {
    int res;
    res = wclrtoeol (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wclrtoeol */

#ifdef HAVE_wdelch
/* From `/usr/include/curses.h:347'.  */
int chkr_stub_wdelch (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wdelch"));
int
chkr_stub_wdelch (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wdelch);
#else
  return wdelch (arg0);
  {
    int res;
    res = wdelch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wdelch */

#ifdef HAVE_w32echochar
/* From `/usr/include/curses.h:347'.  */
int chkr_stub_w32echochar (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("w32echochar"));
int
chkr_stub_w32echochar (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (w32echochar);
#else
  return w32echochar (arg0, arg1);
  {
    int res;
    res = w32echochar (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_w32echochar */

#ifdef HAVE_wgetstr
/* From `/usr/include/curses.h:348'.  */
int chkr_stub_wgetstr (WINDOW * arg0, char * arg1) __asm__ (CHKR_PREFIX ("wgetstr"));
int
chkr_stub_wgetstr (WINDOW * arg0, char * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (wgetstr);
#else
  return wgetstr (arg0, arg1);
  {
    int res;
    res = wgetstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wgetstr */

#ifdef HAVE_wgetnstr
/* From `/usr/include/curses.h:349'.  */
int chkr_stub_wgetnstr (WINDOW * arg0, char * arg1, int arg2) __asm__ (CHKR_PREFIX ("wgetnstr"));
int
chkr_stub_wgetnstr (WINDOW * arg0, char * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (wgetnstr);
#else
  return wgetnstr (arg0, arg1, arg2);
  {
    int res;
    res = wgetnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wgetnstr */

#ifdef HAVE_whline
/* From `/usr/include/curses.h:350'.  */
int chkr_stub_whline (WINDOW * arg0, chtype arg1, int arg2) __asm__ (CHKR_PREFIX ("whline"));
int
chkr_stub_whline (WINDOW * arg0, chtype arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (whline);
#else
  return whline (arg0, arg1, arg2);
  {
    int res;
    res = whline (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_whline */

#ifdef HAVE_wvline
/* From `/usr/include/curses.h:351'.  */
int chkr_stub_wvline (WINDOW * arg0, chtype arg1, int arg2) __asm__ (CHKR_PREFIX ("wvline"));
int
chkr_stub_wvline (WINDOW * arg0, chtype arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wvline);
#else
  return wvline (arg0, arg1, arg2);
  {
    int res;
    res = wvline (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wvline */

#ifdef HAVE_winchnstr
/* From `/usr/include/curses.h:352'.  */
int chkr_stub_winchnstr (WINDOW * arg0, chtype * arg1, int arg2) __asm__ (CHKR_PREFIX ("winchnstr"));
int
chkr_stub_winchnstr (WINDOW * arg0, chtype * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winchnstr);
#else
  return winchnstr (arg0, arg1, arg2);
  {
    int res;
    res = winchnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winchnstr */

#ifdef HAVE_winchstr
/* From `/usr/include/curses.h:353'.  */
int chkr_stub_winchstr (WINDOW * arg0, chtype * arg1) __asm__ (CHKR_PREFIX ("winchstr"));
int
chkr_stub_winchstr (WINDOW * arg0, chtype * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winchstr);
#else
  return winchstr (arg0, arg1);
  {
    int res;
    res = winchstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winchstr */

#ifdef HAVE_winnstr
/* From `/usr/include/curses.h:354'.  */
int chkr_stub_winnstr (WINDOW * arg0, char * arg1, int arg2) __asm__ (CHKR_PREFIX ("winnstr"));
int
chkr_stub_winnstr (WINDOW * arg0, char * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winnstr);
#else
  return winnstr (arg0, arg1, arg2);
  {
    int res;
    res = winnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winnstr */

#ifdef HAVE_w32insch
/* From `/usr/include/curses.h:355'.  */
int chkr_stub_w32insch (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("w32insch"));
int
chkr_stub_w32insch (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (w32insch);
#else
  return w32insch (arg0, arg1);
  {
    int res;
    res = w32insch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_w32insch */

#ifdef HAVE_winsdelln
/* From `/usr/include/curses.h:356'.  */
int chkr_stub_winsdelln (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("winsdelln"));
int
chkr_stub_winsdelln (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (winsdelln);
#else
  return winsdelln (arg0, arg1);
  {
    int res;
    res = winsdelln (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winsdelln */

#ifdef HAVE_winsnstr
/* From `/usr/include/curses.h:357'.  */
int chkr_stub_winsnstr (WINDOW * arg0, char * arg1, int arg2) __asm__ (CHKR_PREFIX ("winsnstr"));
int
chkr_stub_winsnstr (WINDOW * arg0, char * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winsnstr);
#else
  return winsnstr (arg0, arg1, arg2);
  {
    int res;
    res = winsnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winsnstr */

#ifdef HAVE_winstr
/* From `/usr/include/curses.h:358'.  */
int chkr_stub_winstr (WINDOW * arg0, char * arg1) __asm__ (CHKR_PREFIX ("winstr"));
int
chkr_stub_winstr (WINDOW * arg0, char * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winstr);
#else
  return winstr (arg0, arg1);
  {
    int res;
    res = winstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winstr */

#ifdef HAVE_wmove
/* From `/usr/include/curses.h:359'.  */
int chkr_stub_wmove (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("wmove"));
int
chkr_stub_wmove (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wmove);
#else
  return wmove (arg0, arg1, arg2);
  {
    int res;
    res = wmove (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wmove */

#ifdef HAVE_wnoutrefresh
/* From `/usr/include/curses.h:360'.  */
int chkr_stub_wnoutrefresh (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wnoutrefresh"));
int
chkr_stub_wnoutrefresh (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wnoutrefresh);
#else
  return wnoutrefresh (arg0);
  {
    int res;
    res = wnoutrefresh (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wnoutrefresh */

#ifdef HAVE_wredrawln
/* From `/usr/include/curses.h:361'.  */
int chkr_stub_wredrawln (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("wredrawln"));
int
chkr_stub_wredrawln (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wredrawln);
#else
  return wredrawln (arg0, arg1, arg2);
  {
    int res;
    res = wredrawln (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wredrawln */

#ifdef HAVE_wscrl
/* From `/usr/include/curses.h:362'.  */
int chkr_stub_wscrl (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("wscrl"));
int
chkr_stub_wscrl (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wscrl);
#else
  return wscrl (arg0, arg1);
  {
    int res;
    res = wscrl (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wscrl */

#ifdef HAVE_wsetscrreg
/* From `/usr/include/curses.h:363'.  */
int chkr_stub_wsetscrreg (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("wsetscrreg"));
int
chkr_stub_wsetscrreg (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wsetscrreg);
#else
  return wsetscrreg (arg0, arg1, arg2);
  {
    int res;
    res = wsetscrreg (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wsetscrreg */

#ifdef HAVE_wtouchln
/* From `/usr/include/curses.h:364'.  */
int chkr_stub_wtouchln (WINDOW * arg0, int arg1, int arg2, int arg3) __asm__ (CHKR_PREFIX ("wtouchln"));
int
chkr_stub_wtouchln (WINDOW * arg0, int arg1, int arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wtouchln);
#else
  return wtouchln (arg0, arg1, arg2, arg3);
  {
    int res;
    res = wtouchln (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wtouchln */

#ifdef HAVE_crmode
/* From `/usr/include/curses.h:366'.  */
int chkr_stub_crmode (void ) __asm__ (CHKR_PREFIX ("crmode"));
int
chkr_stub_crmode (void )
{
#if USE_BI_JUMP
  __builtin_jump (crmode);
#else
  return crmode ();
  {
    int res;
    res = crmode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_crmode */

#ifdef HAVE_nocrmode
/* From `/usr/include/curses.h:366'.  */
int chkr_stub_nocrmode (void ) __asm__ (CHKR_PREFIX ("nocrmode"));
int
chkr_stub_nocrmode (void )
{
#if USE_BI_JUMP
  __builtin_jump (nocrmode);
#else
  return nocrmode ();
  {
    int res;
    res = nocrmode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_nocrmode */

#ifdef HAVE_ungetch
/* From `/usr/include/curses.h:366'.  */
int chkr_stub_ungetch (int arg0) __asm__ (CHKR_PREFIX ("ungetch"));
int
chkr_stub_ungetch (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (ungetch);
#else
  return ungetch (arg0);
  {
    int res;
    res = ungetch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_ungetch */

#ifdef HAVE_mouse_set
/* From `/usr/include/curses.h:368'.  */
int chkr_stub_mouse_set (long int arg0) __asm__ (CHKR_PREFIX ("mouse_set"));
int
chkr_stub_mouse_set (long int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (mouse_set);
#else
  return mouse_set (arg0);
  {
    int res;
    res = mouse_set (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mouse_set */

#ifdef HAVE_mouse_on
/* From `/usr/include/curses.h:368'.  */
int chkr_stub_mouse_on (long int arg0) __asm__ (CHKR_PREFIX ("mouse_on"));
int
chkr_stub_mouse_on (long int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (mouse_on);
#else
  return mouse_on (arg0);
  {
    int res;
    res = mouse_on (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mouse_on */

#ifdef HAVE_mouse_off
/* From `/usr/include/curses.h:369'.  */
int chkr_stub_mouse_off (long int arg0) __asm__ (CHKR_PREFIX ("mouse_off"));
int
chkr_stub_mouse_off (long int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (mouse_off);
#else
  return mouse_off (arg0);
  {
    int res;
    res = mouse_off (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mouse_off */

#ifdef HAVE_request_mouse_pos
/* From `/usr/include/curses.h:369'.  */
int chkr_stub_request_mouse_pos (void ) __asm__ (CHKR_PREFIX ("request_mouse_pos"));
int
chkr_stub_request_mouse_pos (void )
{
#if USE_BI_JUMP
  __builtin_jump (request_mouse_pos);
#else
  return request_mouse_pos ();
  {
    int res;
    res = request_mouse_pos ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_request_mouse_pos */

#ifdef HAVE_map_button
/* From `/usr/include/curses.h:370'.  */
int chkr_stub_map_button (long unsigned int arg0) __asm__ (CHKR_PREFIX ("map_button"));
int
chkr_stub_map_button (long unsigned int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (map_button);
#else
  return map_button (arg0);
  {
    int res;
    res = map_button (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_map_button */

#ifdef HAVE_wmouse_position
/* From `/usr/include/curses.h:372'.  */
void chkr_stub_wmouse_position (WINDOW * arg0, int * arg1, int * arg2) __asm__ (CHKR_PREFIX ("wmouse_position"));
void
chkr_stub_wmouse_position (WINDOW * arg0, int * arg1, int * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (int), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (int), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (wmouse_position);
#else
  wmouse_position (arg0, arg1, arg2);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wmouse_position */

#ifdef HAVE_getmouse
/* From `/usr/include/curses.h:374'.  */
long unsigned int chkr_stub_getmouse (void ) __asm__ (CHKR_PREFIX ("getmouse"));
long unsigned int
chkr_stub_getmouse (void )
{
#if USE_BI_JUMP
  __builtin_jump (getmouse);
#else
  return getmouse ();
  {
    long unsigned int res;
    res = getmouse ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getmouse */

#ifdef HAVE_getbmap
/* From `/usr/include/curses.h:374'.  */
long unsigned int chkr_stub_getbmap (void ) __asm__ (CHKR_PREFIX ("getbmap"));
long unsigned int
chkr_stub_getbmap (void )
{
#if USE_BI_JUMP
  __builtin_jump (getbmap);
#else
  return getbmap ();
  {
    long unsigned int res;
    res = getbmap ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getbmap */

#ifdef HAVE_pair_content
/* From `/usr/include/curses.h:382'.  */
int chkr_stub_pair_content (int arg0, short int * arg1, short int * arg2) __asm__ (CHKR_PREFIX ("pair_content"));
int
chkr_stub_pair_content (int arg0, short int * arg1, short int * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg1, sizeof (short int), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (short int), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (pair_content);
#else
  return pair_content (arg0, arg1, arg2);
  {
    int res;
    res = pair_content (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_pair_content */

#ifdef HAVE_color_content
/* From `/usr/include/curses.h:383'.  */
int chkr_stub_color_content (int arg0, short int * arg1, short int * arg2, short int * arg3) __asm__ (CHKR_PREFIX ("color_content"));
int
chkr_stub_color_content (int arg0, short int * arg1, short int * arg2, short int * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg1, sizeof (short int), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (short int), CHKR_XX, "arg2");
  stubs_chkr_check_addr (arg3, sizeof (short int), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (color_content);
#else
  return color_content (arg0, arg1, arg2, arg3);
  {
    int res;
    res = color_content (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_color_content */

#ifdef HAVE_init_color
/* From `/usr/include/curses.h:384'.  */
int chkr_stub_init_color (int arg0, int arg1, int arg2, int arg3) __asm__ (CHKR_PREFIX ("init_color"));
int
chkr_stub_init_color (int arg0, int arg1, int arg2, int arg3)
{
#if USE_BI_JUMP
  __builtin_jump (init_color);
#else
  return init_color (arg0, arg1, arg2, arg3);
  {
    int res;
    res = init_color (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_init_color */

#ifdef HAVE_init_pair
/* From `/usr/include/curses.h:385'.  */
int chkr_stub_init_pair (int arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("init_pair"));
int
chkr_stub_init_pair (int arg0, int arg1, int arg2)
{
#if USE_BI_JUMP
  __builtin_jump (init_pair);
#else
  return init_pair (arg0, arg1, arg2);
  {
    int res;
    res = init_pair (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_init_pair */

#ifdef HAVE_idlok
/* From `/usr/include/curses.h:386'.  */
int chkr_stub_idlok (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("idlok"));
int
chkr_stub_idlok (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (idlok);
#else
  return idlok (arg0, arg1);
  {
    int res;
    res = idlok (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_idlok */

#ifdef HAVE_immedok
/* From `/usr/include/curses.h:388'.  */
void chkr_stub_immedok (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("immedok"));
void
chkr_stub_immedok (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (immedok);
#else
  immedok (arg0, arg1);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_immedok */

#ifdef HAVE_winwch
/* From `/usr/include/curses.h:390'.  */
chtype chkr_stub_winwch (WINDOW * arg0) __asm__ (CHKR_PREFIX ("winwch"));
chtype
chkr_stub_winwch (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (winwch);
#else
  return winwch (arg0);
  {
    chtype res;
    res = winwch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winwch */

#ifdef HAVE_pechowchar
/* From `/usr/include/curses.h:392'.  */
int chkr_stub_pechowchar (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("pechowchar"));
int
chkr_stub_pechowchar (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (pechowchar);
#else
  return pechowchar (arg0, arg1);
  {
    int res;
    res = pechowchar (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_pechowchar */

#ifdef HAVE_ungetwch
/* From `/usr/include/curses.h:392'.  */
int chkr_stub_ungetwch (int arg0) __asm__ (CHKR_PREFIX ("ungetwch"));
int
chkr_stub_ungetwch (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (ungetwch);
#else
  return ungetwch (arg0);
  {
    int res;
    res = ungetwch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_ungetwch */

#ifdef HAVE_waddnwstr
/* From `/usr/include/curses.h:393'.  */
int chkr_stub_waddnwstr (WINDOW * arg0, wchar_t * arg1, int arg2) __asm__ (CHKR_PREFIX ("waddnwstr"));
int
chkr_stub_waddnwstr (WINDOW * arg0, wchar_t * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddnwstr);
#else
  return waddnwstr (arg0, arg1, arg2);
  {
    int res;
    res = waddnwstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddnwstr */

#ifdef HAVE_waddwch
/* From `/usr/include/curses.h:394'.  */
int chkr_stub_waddwch (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("waddwch"));
int
chkr_stub_waddwch (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (waddwch);
#else
  return waddwch (arg0, arg1);
  {
    int res;
    res = waddwch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddwch */

#ifdef HAVE_waddwchnstr
/* From `/usr/include/curses.h:395'.  */
int chkr_stub_waddwchnstr (WINDOW * arg0, chtype * arg1, int arg2) __asm__ (CHKR_PREFIX ("waddwchnstr"));
int
chkr_stub_waddwchnstr (WINDOW * arg0, chtype * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddwchnstr);
#else
  return waddwchnstr (arg0, arg1, arg2);
  {
    int res;
    res = waddwchnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddwchnstr */

#ifdef HAVE_wechowchar
/* From `/usr/include/curses.h:396'.  */
int chkr_stub_wechowchar (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("wechowchar"));
int
chkr_stub_wechowchar (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wechowchar);
#else
  return wechowchar (arg0, arg1);
  {
    int res;
    res = wechowchar (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wechowchar */

#ifdef HAVE_wgetnwstr
/* From `/usr/include/curses.h:397'.  */
int chkr_stub_wgetnwstr (WINDOW * arg0, wchar_t * arg1, int arg2) __asm__ (CHKR_PREFIX ("wgetnwstr"));
int
chkr_stub_wgetnwstr (WINDOW * arg0, wchar_t * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (wgetnwstr);
#else
  return wgetnwstr (arg0, arg1, arg2);
  {
    int res;
    res = wgetnwstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wgetnwstr */

#ifdef HAVE_wgetwch
/* From `/usr/include/curses.h:398'.  */
int chkr_stub_wgetwch (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wgetwch"));
int
chkr_stub_wgetwch (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wgetwch);
#else
  return wgetwch (arg0);
  {
    int res;
    res = wgetwch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wgetwch */

#ifdef HAVE_wgetwstr
/* From `/usr/include/curses.h:399'.  */
int chkr_stub_wgetwstr (WINDOW * arg0, wchar_t * arg1) __asm__ (CHKR_PREFIX ("wgetwstr"));
int
chkr_stub_wgetwstr (WINDOW * arg0, wchar_t * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (wgetwstr);
#else
  return wgetwstr (arg0, arg1);
  {
    int res;
    res = wgetwstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wgetwstr */

#ifdef HAVE_winnwstr
/* From `/usr/include/curses.h:400'.  */
int chkr_stub_winnwstr (WINDOW * arg0, wchar_t * arg1, int arg2) __asm__ (CHKR_PREFIX ("winnwstr"));
int
chkr_stub_winnwstr (WINDOW * arg0, wchar_t * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winnwstr);
#else
  return winnwstr (arg0, arg1, arg2);
  {
    int res;
    res = winnwstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winnwstr */

#ifdef HAVE_winsnwstr
/* From `/usr/include/curses.h:401'.  */
int chkr_stub_winsnwstr (WINDOW * arg0, wchar_t * arg1, int arg2) __asm__ (CHKR_PREFIX ("winsnwstr"));
int
chkr_stub_winsnwstr (WINDOW * arg0, wchar_t * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winsnwstr);
#else
  return winsnwstr (arg0, arg1, arg2);
  {
    int res;
    res = winsnwstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winsnwstr */

#ifdef HAVE_winswch
/* From `/usr/include/curses.h:402'.  */
int chkr_stub_winswch (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("winswch"));
int
chkr_stub_winswch (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (winswch);
#else
  return winswch (arg0, arg1);
  {
    int res;
    res = winswch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winswch */

#ifdef HAVE_winwchnstr
/* From `/usr/include/curses.h:403'.  */
int chkr_stub_winwchnstr (WINDOW * arg0, chtype * arg1, int arg2) __asm__ (CHKR_PREFIX ("winwchnstr"));
int
chkr_stub_winwchnstr (WINDOW * arg0, chtype * arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winwchnstr);
#else
  return winwchnstr (arg0, arg1, arg2);
  {
    int res;
    res = winwchnstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winwchnstr */

#ifdef HAVE_winwstr
/* From `/usr/include/curses.h:404'.  */
int chkr_stub_winwstr (WINDOW * arg0, wchar_t * arg1) __asm__ (CHKR_PREFIX ("winwstr"));
int
chkr_stub_winwstr (WINDOW * arg0, wchar_t * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winwstr);
#else
  return winwstr (arg0, arg1);
  {
    int res;
    res = winwstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winwstr */

#ifdef HAVE_getcury
/* From `/usr/include/curses.h:518'.  */
int chkr_stub_getcury (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getcury"));
int
chkr_stub_getcury (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getcury);
#else
  return getcury (arg0);
  {
    int res;
    res = getcury (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getcury */

#ifdef HAVE_getcurx
/* From `/usr/include/curses.h:518'.  */
int chkr_stub_getcurx (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getcurx"));
int
chkr_stub_getcurx (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getcurx);
#else
  return getcurx (arg0);
  {
    int res;
    res = getcurx (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getcurx */

#ifdef HAVE_getbegy
/* From `/usr/include/curses.h:519'.  */
int chkr_stub_getbegy (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getbegy"));
int
chkr_stub_getbegy (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getbegy);
#else
  return getbegy (arg0);
  {
    int res;
    res = getbegy (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getbegy */

#ifdef HAVE_getbegx
/* From `/usr/include/curses.h:519'.  */
int chkr_stub_getbegx (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getbegx"));
int
chkr_stub_getbegx (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getbegx);
#else
  return getbegx (arg0);
  {
    int res;
    res = getbegx (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getbegx */

#ifdef HAVE_getmaxy
/* From `/usr/include/curses.h:520'.  */
int chkr_stub_getmaxy (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getmaxy"));
int
chkr_stub_getmaxy (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getmaxy);
#else
  return getmaxy (arg0);
  {
    int res;
    res = getmaxy (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getmaxy */

#ifdef HAVE_getmaxx
/* From `/usr/include/curses.h:520'.  */
int chkr_stub_getmaxx (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getmaxx"));
int
chkr_stub_getmaxx (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getmaxx);
#else
  return getmaxx (arg0);
  {
    int res;
    res = getmaxx (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getmaxx */

#ifdef HAVE_getpary
/* From `/usr/include/curses.h:521'.  */
int chkr_stub_getpary (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getpary"));
int
chkr_stub_getpary (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getpary);
#else
  return getpary (arg0);
  {
    int res;
    res = getpary (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getpary */

#ifdef HAVE_getparx
/* From `/usr/include/curses.h:521'.  */
int chkr_stub_getparx (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getparx"));
int
chkr_stub_getparx (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getparx);
#else
  return getparx (arg0);
  {
    int res;
    res = getparx (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getparx */

#ifdef HAVE_getbkgd
/* From `/usr/include/curses.h:523'.  */
chtype chkr_stub_getbkgd (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getbkgd"));
chtype
chkr_stub_getbkgd (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getbkgd);
#else
  return getbkgd (arg0);
  {
    chtype res;
    res = getbkgd (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getbkgd */

#ifdef HAVE_getattrs
/* From `/usr/include/curses.h:523'.  */
chtype chkr_stub_getattrs (WINDOW * arg0) __asm__ (CHKR_PREFIX ("getattrs"));
chtype
chkr_stub_getattrs (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getattrs);
#else
  return getattrs (arg0);
  {
    chtype res;
    res = getattrs (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getattrs */

#ifdef HAVE_newterm32
/* From `/usr/include/curses.h:538'.  */
SCREEN * chkr_stub_newterm32 (char * arg0, FILE * arg1, FILE * arg2) __asm__ (CHKR_PREFIX ("newterm32"));
SCREEN *
chkr_stub_newterm32 (char * arg0, FILE * arg1, FILE * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (FILE), CHKR_XX, "arg1");
  stubs_chkr_check_addr (arg2, sizeof (FILE), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (newterm32);
#else
  return newterm32 (arg0, arg1, arg2);
  {
    SCREEN * res;
    res = newterm32 (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_newterm32 */

#ifdef HAVE_set_term
/* From `/usr/include/curses.h:539'.  */
SCREEN * chkr_stub_set_term (SCREEN * arg0) __asm__ (CHKR_PREFIX ("set_term"));
SCREEN *
chkr_stub_set_term (SCREEN * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (SCREEN), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (set_term);
#else
  return set_term (arg0);
  {
    SCREEN * res;
    res = set_term (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_set_term */

#ifdef HAVE_subpad
/* From `/usr/include/curses.h:541'.  */
WINDOW * chkr_stub_subpad (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4) __asm__ (CHKR_PREFIX ("subpad"));
WINDOW *
chkr_stub_subpad (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (subpad);
#else
  return subpad (arg0, arg1, arg2, arg3, arg4);
  {
    WINDOW * res;
    res = subpad (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_subpad */

#ifdef HAVE_subwin
/* From `/usr/include/curses.h:542'.  */
WINDOW * chkr_stub_subwin (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4) __asm__ (CHKR_PREFIX ("subwin"));
WINDOW *
chkr_stub_subwin (WINDOW * arg0, int arg1, int arg2, int arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (subwin);
#else
  return subwin (arg0, arg1, arg2, arg3, arg4);
  {
    WINDOW * res;
    res = subwin (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_subwin */

#ifdef HAVE_unctrl
/* From `/usr/include/curses.h:544'.  */
char * chkr_stub_unctrl (int arg0) __asm__ (CHKR_PREFIX ("unctrl"));
char *
chkr_stub_unctrl (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (unctrl);
#else
  return unctrl (arg0);
  {
    char * res;
    res = unctrl (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_unctrl */

#ifdef HAVE_inch
/* From `/usr/include/curses.h:546'.  */
chtype chkr_stub_inch (void ) __asm__ (CHKR_PREFIX ("inch"));
chtype
chkr_stub_inch (void )
{
#if USE_BI_JUMP
  __builtin_jump (inch);
#else
  return inch ();
  {
    chtype res;
    res = inch ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inch */

#ifdef HAVE_winch
/* From `/usr/include/curses.h:546'.  */
chtype chkr_stub_winch (WINDOW * arg0) __asm__ (CHKR_PREFIX ("winch"));
chtype
chkr_stub_winch (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (winch);
#else
  return winch (arg0);
  {
    chtype res;
    res = winch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winch */

#ifdef HAVE_mvinch
/* From `/usr/include/curses.h:546'.  */
chtype chkr_stub_mvinch (int arg0, int arg1) __asm__ (CHKR_PREFIX ("mvinch"));
chtype
chkr_stub_mvinch (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (mvinch);
#else
  return mvinch (arg0, arg1);
  {
    chtype res;
    res = mvinch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinch */

#ifdef HAVE_mvwinch
/* From `/usr/include/curses.h:547'.  */
chtype chkr_stub_mvwinch (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("mvwinch"));
chtype
chkr_stub_mvwinch (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwinch);
#else
  return mvwinch (arg0, arg1, arg2);
  {
    chtype res;
    res = mvwinch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinch */

#ifdef HAVE_addch
/* From `/usr/include/curses.h:549'.  */
int chkr_stub_addch (chtype arg0) __asm__ (CHKR_PREFIX ("addch"));
int
chkr_stub_addch (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (addch);
#else
  return addch (arg0);
  {
    int res;
    res = addch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addch */

#ifdef HAVE_addchnstr
/* From `/usr/include/curses.h:549'.  */
int chkr_stub_addchnstr (chtype * arg0, int arg1) __asm__ (CHKR_PREFIX ("addchnstr"));
int
chkr_stub_addchnstr (chtype * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addchnstr);
#else
  return addchnstr (arg0, arg1);
  {
    int res;
    res = addchnstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addchnstr */

#ifdef HAVE_addchstr
/* From `/usr/include/curses.h:549'.  */
int chkr_stub_addchstr (chtype * arg0) __asm__ (CHKR_PREFIX ("addchstr"));
int
chkr_stub_addchstr (chtype * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addchstr);
#else
  return addchstr (arg0);
  {
    int res;
    res = addchstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addchstr */

#ifdef HAVE_addnstr
/* From `/usr/include/curses.h:550'.  */
int chkr_stub_addnstr (char * arg0, int arg1) __asm__ (CHKR_PREFIX ("addnstr"));
int
chkr_stub_addnstr (char * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addnstr);
#else
  return addnstr (arg0, arg1);
  {
    int res;
    res = addnstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addnstr */

#ifdef HAVE_addstr
/* From `/usr/include/curses.h:550'.  */
int chkr_stub_addstr (char * arg0) __asm__ (CHKR_PREFIX ("addstr"));
int
chkr_stub_addstr (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addstr);
#else
  return addstr (arg0);
  {
    int res;
    res = addstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addstr */

#ifdef HAVE_attroff
/* From `/usr/include/curses.h:551'.  */
int chkr_stub_attroff (chtype arg0) __asm__ (CHKR_PREFIX ("attroff"));
int
chkr_stub_attroff (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (attroff);
#else
  return attroff (arg0);
  {
    int res;
    res = attroff (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_attroff */

#ifdef HAVE_attron
/* From `/usr/include/curses.h:551'.  */
int chkr_stub_attron (chtype arg0) __asm__ (CHKR_PREFIX ("attron"));
int
chkr_stub_attron (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (attron);
#else
  return attron (arg0);
  {
    int res;
    res = attron (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_attron */

#ifdef HAVE_attrset
/* From `/usr/include/curses.h:551'.  */
int chkr_stub_attrset (chtype arg0) __asm__ (CHKR_PREFIX ("attrset"));
int
chkr_stub_attrset (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (attrset);
#else
  return attrset (arg0);
  {
    int res;
    res = attrset (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_attrset */

#ifdef HAVE_beep
/* From `/usr/include/curses.h:552'.  */
int chkr_stub_beep (void ) __asm__ (CHKR_PREFIX ("beep"));
int
chkr_stub_beep (void )
{
#if USE_BI_JUMP
  __builtin_jump (beep);
#else
  return beep ();
  {
    int res;
    res = beep ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_beep */

#ifdef HAVE_bkgd
/* From `/usr/include/curses.h:552'.  */
int chkr_stub_bkgd (chtype arg0) __asm__ (CHKR_PREFIX ("bkgd"));
int
chkr_stub_bkgd (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (bkgd);
#else
  return bkgd (arg0);
  {
    int res;
    res = bkgd (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_bkgd */

#ifdef HAVE_border
/* From `/usr/include/curses.h:554'.  */
int chkr_stub_border (chtype arg0, chtype arg1, chtype arg2, chtype arg3, chtype arg4, chtype arg5, chtype arg6, chtype arg7) __asm__ (CHKR_PREFIX ("border"));
int
chkr_stub_border (chtype arg0, chtype arg1, chtype arg2, chtype arg3, chtype arg4, chtype arg5, chtype arg6, chtype arg7)
{
#if USE_BI_JUMP
  __builtin_jump (border);
#else
  return border (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
  {
    int res;
    res = border (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_border */

#ifdef HAVE_box32
/* From `/usr/include/curses.h:555'.  */
int chkr_stub_box32 (WINDOW * arg0, chtype arg1, chtype arg2) __asm__ (CHKR_PREFIX ("box32"));
int
chkr_stub_box32 (WINDOW * arg0, chtype arg1, chtype arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (box32);
#else
  return box32 (arg0, arg1, arg2);
  {
    int res;
    res = box32 (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_box32 */

#ifdef HAVE_clear
/* From `/usr/include/curses.h:556'.  */
int chkr_stub_clear (void ) __asm__ (CHKR_PREFIX ("clear"));
int
chkr_stub_clear (void )
{
#if USE_BI_JUMP
  __builtin_jump (clear);
#else
  return clear ();
  {
    int res;
    res = clear ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_clear */

#ifdef HAVE_clearok
/* From `/usr/include/curses.h:556'.  */
int chkr_stub_clearok (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("clearok"));
int
chkr_stub_clearok (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (clearok);
#else
  return clearok (arg0, arg1);
  {
    int res;
    res = clearok (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_clearok */

#ifdef HAVE_clrtobot
/* From `/usr/include/curses.h:557'.  */
int chkr_stub_clrtobot (void ) __asm__ (CHKR_PREFIX ("clrtobot"));
int
chkr_stub_clrtobot (void )
{
#if USE_BI_JUMP
  __builtin_jump (clrtobot);
#else
  return clrtobot ();
  {
    int res;
    res = clrtobot ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_clrtobot */

#ifdef HAVE_clrtoeol
/* From `/usr/include/curses.h:557'.  */
int chkr_stub_clrtoeol (void ) __asm__ (CHKR_PREFIX ("clrtoeol"));
int
chkr_stub_clrtoeol (void )
{
#if USE_BI_JUMP
  __builtin_jump (clrtoeol);
#else
  return clrtoeol ();
  {
    int res;
    res = clrtoeol ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_clrtoeol */

#ifdef HAVE_crmode
/* From `/usr/include/curses.h:558'.  */
int chkr_stub_crmode (void ) __asm__ (CHKR_PREFIX ("crmode"));
int
chkr_stub_crmode (void )
{
#if USE_BI_JUMP
  __builtin_jump (crmode);
#else
  return crmode ();
  {
    int res;
    res = crmode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_crmode */

#ifdef HAVE_delch
/* From `/usr/include/curses.h:558'.  */
int chkr_stub_delch (void ) __asm__ (CHKR_PREFIX ("delch"));
int
chkr_stub_delch (void )
{
#if USE_BI_JUMP
  __builtin_jump (delch);
#else
  return delch ();
  {
    int res;
    res = delch ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_delch */

#ifdef HAVE_deleteln
/* From `/usr/include/curses.h:558'.  */
int chkr_stub_deleteln (void ) __asm__ (CHKR_PREFIX ("deleteln"));
int
chkr_stub_deleteln (void )
{
#if USE_BI_JUMP
  __builtin_jump (deleteln);
#else
  return deleteln ();
  {
    int res;
    res = deleteln ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_deleteln */

#ifdef HAVE_echo
/* From `/usr/include/curses.h:559'.  */
int chkr_stub_echo (void ) __asm__ (CHKR_PREFIX ("echo"));
int
chkr_stub_echo (void )
{
#if USE_BI_JUMP
  __builtin_jump (echo);
#else
  return echo ();
  {
    int res;
    res = echo ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_echo */

#ifdef HAVE_echochar
/* From `/usr/include/curses.h:559'.  */
int chkr_stub_echochar (chtype arg0) __asm__ (CHKR_PREFIX ("echochar"));
int
chkr_stub_echochar (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (echochar);
#else
  return echochar (arg0);
  {
    int res;
    res = echochar (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_echochar */

#ifdef HAVE_erase
/* From `/usr/include/curses.h:559'.  */
int chkr_stub_erase (void ) __asm__ (CHKR_PREFIX ("erase"));
int
chkr_stub_erase (void )
{
#if USE_BI_JUMP
  __builtin_jump (erase);
#else
  return erase ();
  {
    int res;
    res = erase ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_erase */

#ifdef HAVE_fixterm
/* From `/usr/include/curses.h:560'.  */
int chkr_stub_fixterm (void ) __asm__ (CHKR_PREFIX ("fixterm"));
int
chkr_stub_fixterm (void )
{
#if USE_BI_JUMP
  __builtin_jump (fixterm);
#else
  return fixterm ();
  {
    int res;
    res = fixterm ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_fixterm */

#ifdef HAVE_flash
/* From `/usr/include/curses.h:561'.  */
int chkr_stub_flash (void ) __asm__ (CHKR_PREFIX ("flash"));
int
chkr_stub_flash (void )
{
#if USE_BI_JUMP
  __builtin_jump (flash);
#else
  return flash ();
  {
    int res;
    res = flash ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_flash */

#ifdef HAVE_garbagedlines
/* From `/usr/include/curses.h:561'.  */
int chkr_stub_garbagedlines (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("garbagedlines"));
int
chkr_stub_garbagedlines (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (garbagedlines);
#else
  return garbagedlines (arg0, arg1, arg2);
  {
    int res;
    res = garbagedlines (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_garbagedlines */

#ifdef HAVE_garbagedwin
/* From `/usr/include/curses.h:562'.  */
int chkr_stub_garbagedwin (WINDOW * arg0) __asm__ (CHKR_PREFIX ("garbagedwin"));
int
chkr_stub_garbagedwin (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (garbagedwin);
#else
  return garbagedwin (arg0);
  {
    int res;
    res = garbagedwin (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_garbagedwin */

#ifdef HAVE_getch
/* From `/usr/include/curses.h:563'.  */
int chkr_stub_getch (void ) __asm__ (CHKR_PREFIX ("getch"));
int
chkr_stub_getch (void )
{
#if USE_BI_JUMP
  __builtin_jump (getch);
#else
  return getch ();
  {
    int res;
    res = getch ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getch */

#ifdef HAVE_getstr
/* From `/usr/include/curses.h:563'.  */
int chkr_stub_getstr (char * arg0) __asm__ (CHKR_PREFIX ("getstr"));
int
chkr_stub_getstr (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getstr);
#else
  return getstr (arg0);
  {
    int res;
    res = getstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getstr */

#ifdef HAVE_gettmode
/* From `/usr/include/curses.h:563'.  */
int chkr_stub_gettmode (void ) __asm__ (CHKR_PREFIX ("gettmode"));
int
chkr_stub_gettmode (void )
{
#if USE_BI_JUMP
  __builtin_jump (gettmode);
#else
  return gettmode ();
  {
    int res;
    res = gettmode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_gettmode */

#ifdef HAVE_halfdelay
/* From `/usr/include/curses.h:564'.  */
int chkr_stub_halfdelay (int arg0) __asm__ (CHKR_PREFIX ("halfdelay"));
int
chkr_stub_halfdelay (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (halfdelay);
#else
  return halfdelay (arg0);
  {
    int res;
    res = halfdelay (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_halfdelay */

#ifdef HAVE_hline
/* From `/usr/include/curses.h:564'.  */
int chkr_stub_hline (chtype arg0, int arg1) __asm__ (CHKR_PREFIX ("hline"));
int
chkr_stub_hline (chtype arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (hline);
#else
  return hline (arg0, arg1);
  {
    int res;
    res = hline (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_hline */

#ifdef HAVE_inchnstr
/* From `/usr/include/curses.h:565'.  */
int chkr_stub_inchnstr (chtype * arg0, int arg1) __asm__ (CHKR_PREFIX ("inchnstr"));
int
chkr_stub_inchnstr (chtype * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (inchnstr);
#else
  return inchnstr (arg0, arg1);
  {
    int res;
    res = inchnstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inchnstr */

#ifdef HAVE_inchstr
/* From `/usr/include/curses.h:565'.  */
int chkr_stub_inchstr (chtype * arg0) __asm__ (CHKR_PREFIX ("inchstr"));
int
chkr_stub_inchstr (chtype * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (inchstr);
#else
  return inchstr (arg0);
  {
    int res;
    res = inchstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inchstr */

#ifdef HAVE_innstr
/* From `/usr/include/curses.h:566'.  */
int chkr_stub_innstr (char * arg0, int arg1) __asm__ (CHKR_PREFIX ("innstr"));
int
chkr_stub_innstr (char * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (innstr);
#else
  return innstr (arg0, arg1);
  {
    int res;
    res = innstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_innstr */

#ifdef HAVE_insch
/* From `/usr/include/curses.h:566'.  */
int chkr_stub_insch (chtype arg0) __asm__ (CHKR_PREFIX ("insch"));
int
chkr_stub_insch (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (insch);
#else
  return insch (arg0);
  {
    int res;
    res = insch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_insch */

#ifdef HAVE_insdelln
/* From `/usr/include/curses.h:567'.  */
int chkr_stub_insdelln (int arg0) __asm__ (CHKR_PREFIX ("insdelln"));
int
chkr_stub_insdelln (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (insdelln);
#else
  return insdelln (arg0);
  {
    int res;
    res = insdelln (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_insdelln */

#ifdef HAVE_insertln
/* From `/usr/include/curses.h:567'.  */
int chkr_stub_insertln (void ) __asm__ (CHKR_PREFIX ("insertln"));
int
chkr_stub_insertln (void )
{
#if USE_BI_JUMP
  __builtin_jump (insertln);
#else
  return insertln ();
  {
    int res;
    res = insertln ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_insertln */

#ifdef HAVE_insnstr
/* From `/usr/include/curses.h:567'.  */
int chkr_stub_insnstr (char * arg0, int arg1) __asm__ (CHKR_PREFIX ("insnstr"));
int
chkr_stub_insnstr (char * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (insnstr);
#else
  return insnstr (arg0, arg1);
  {
    int res;
    res = insnstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_insnstr */

#ifdef HAVE_insstr
/* From `/usr/include/curses.h:568'.  */
int chkr_stub_insstr (char * arg0) __asm__ (CHKR_PREFIX ("insstr"));
int
chkr_stub_insstr (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (insstr);
#else
  return insstr (arg0);
  {
    int res;
    res = insstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_insstr */

#ifdef HAVE_instr
/* From `/usr/include/curses.h:568'.  */
int chkr_stub_instr (char * arg0) __asm__ (CHKR_PREFIX ("instr"));
int
chkr_stub_instr (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (instr);
#else
  return instr (arg0);
  {
    int res;
    res = instr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_instr */

#ifdef HAVE_intrflush
/* From `/usr/include/curses.h:568'.  */
int chkr_stub_intrflush (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("intrflush"));
int
chkr_stub_intrflush (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (intrflush);
#else
  return intrflush (arg0, arg1);
  {
    int res;
    res = intrflush (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_intrflush */

#ifdef HAVE_is_linetouched
/* From `/usr/include/curses.h:569'.  */
int chkr_stub_is_linetouched (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("is_linetouched"));
int
chkr_stub_is_linetouched (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (is_linetouched);
#else
  return is_linetouched (arg0, arg1);
  {
    int res;
    res = is_linetouched (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_is_linetouched */

#ifdef HAVE_is_wintouched
/* From `/usr/include/curses.h:569'.  */
int chkr_stub_is_wintouched (WINDOW * arg0) __asm__ (CHKR_PREFIX ("is_wintouched"));
int
chkr_stub_is_wintouched (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (is_wintouched);
#else
  return is_wintouched (arg0);
  {
    int res;
    res = is_wintouched (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_is_wintouched */

#ifdef HAVE_leaveok
/* From `/usr/include/curses.h:570'.  */
int chkr_stub_leaveok (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("leaveok"));
int
chkr_stub_leaveok (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (leaveok);
#else
  return leaveok (arg0, arg1);
  {
    int res;
    res = leaveok (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_leaveok */

#ifdef HAVE_meta
/* From `/usr/include/curses.h:571'.  */
int chkr_stub_meta (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("meta"));
int
chkr_stub_meta (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (meta);
#else
  return meta (arg0, arg1);
  {
    int res;
    res = meta (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_meta */

#ifdef HAVE_move
/* From `/usr/include/curses.h:572'.  */
int chkr_stub_move (int arg0, int arg1) __asm__ (CHKR_PREFIX ("move"));
int
chkr_stub_move (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (move);
#else
  return move (arg0, arg1);
  {
    int res;
    res = move (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_move */

#ifdef HAVE_mvaddch
/* From `/usr/include/curses.h:572'.  */
int chkr_stub_mvaddch (int arg0, int arg1, chtype arg2) __asm__ (CHKR_PREFIX ("mvaddch"));
int
chkr_stub_mvaddch (int arg0, int arg1, chtype arg2)
{
#if USE_BI_JUMP
  __builtin_jump (mvaddch);
#else
  return mvaddch (arg0, arg1, arg2);
  {
    int res;
    res = mvaddch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddch */

#ifdef HAVE_mvaddchnstr
/* From `/usr/include/curses.h:573'.  */
int chkr_stub_mvaddchnstr (int arg0, int arg1, chtype * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvaddchnstr"));
int
chkr_stub_mvaddchnstr (int arg0, int arg1, chtype * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddchnstr);
#else
  return mvaddchnstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvaddchnstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddchnstr */

#ifdef HAVE_mvaddchstr
/* From `/usr/include/curses.h:574'.  */
int chkr_stub_mvaddchstr (int arg0, int arg1, chtype * arg2) __asm__ (CHKR_PREFIX ("mvaddchstr"));
int
chkr_stub_mvaddchstr (int arg0, int arg1, chtype * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddchstr);
#else
  return mvaddchstr (arg0, arg1, arg2);
  {
    int res;
    res = mvaddchstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddchstr */

#ifdef HAVE_mvaddnstr
/* From `/usr/include/curses.h:575'.  */
int chkr_stub_mvaddnstr (int arg0, int arg1, char * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvaddnstr"));
int
chkr_stub_mvaddnstr (int arg0, int arg1, char * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (char), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddnstr);
#else
  return mvaddnstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvaddnstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddnstr */

#ifdef HAVE_mvaddstr
/* From `/usr/include/curses.h:576'.  */
int chkr_stub_mvaddstr (int arg0, int arg1, char * arg2) __asm__ (CHKR_PREFIX ("mvaddstr"));
int
chkr_stub_mvaddstr (int arg0, int arg1, char * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (char), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddstr);
#else
  return mvaddstr (arg0, arg1, arg2);
  {
    int res;
    res = mvaddstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddstr */

#ifdef HAVE_mvdelch
/* From `/usr/include/curses.h:577'.  */
int chkr_stub_mvdelch (int arg0, int arg1) __asm__ (CHKR_PREFIX ("mvdelch"));
int
chkr_stub_mvdelch (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (mvdelch);
#else
  return mvdelch (arg0, arg1);
  {
    int res;
    res = mvdelch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvdelch */

#ifdef HAVE_mvgetch
/* From `/usr/include/curses.h:578'.  */
int chkr_stub_mvgetch (int arg0, int arg1) __asm__ (CHKR_PREFIX ("mvgetch"));
int
chkr_stub_mvgetch (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (mvgetch);
#else
  return mvgetch (arg0, arg1);
  {
    int res;
    res = mvgetch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvgetch */

#ifdef HAVE_mvgetstr
/* From `/usr/include/curses.h:579'.  */
int chkr_stub_mvgetstr (int arg0, int arg1, char * arg2) __asm__ (CHKR_PREFIX ("mvgetstr"));
int
chkr_stub_mvgetstr (int arg0, int arg1, char * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (char), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvgetstr);
#else
  return mvgetstr (arg0, arg1, arg2);
  {
    int res;
    res = mvgetstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvgetstr */

#ifdef HAVE_mvhline
/* From `/usr/include/curses.h:580'.  */
int chkr_stub_mvhline (int arg0, int arg1, chtype arg2, int arg3) __asm__ (CHKR_PREFIX ("mvhline"));
int
chkr_stub_mvhline (int arg0, int arg1, chtype arg2, int arg3)
{
#if USE_BI_JUMP
  __builtin_jump (mvhline);
#else
  return mvhline (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvhline (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvhline */

#ifdef HAVE_mvinchnstr
/* From `/usr/include/curses.h:581'.  */
int chkr_stub_mvinchnstr (int arg0, int arg1, chtype * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvinchnstr"));
int
chkr_stub_mvinchnstr (int arg0, int arg1, chtype * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinchnstr);
#else
  return mvinchnstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvinchnstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinchnstr */

#ifdef HAVE_mvinchstr
/* From `/usr/include/curses.h:582'.  */
int chkr_stub_mvinchstr (int arg0, int arg1, chtype * arg2) __asm__ (CHKR_PREFIX ("mvinchstr"));
int
chkr_stub_mvinchstr (int arg0, int arg1, chtype * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinchstr);
#else
  return mvinchstr (arg0, arg1, arg2);
  {
    int res;
    res = mvinchstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinchstr */

#ifdef HAVE_mvinnstr
/* From `/usr/include/curses.h:583'.  */
int chkr_stub_mvinnstr (int arg0, int arg1, char * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvinnstr"));
int
chkr_stub_mvinnstr (int arg0, int arg1, char * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (char), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinnstr);
#else
  return mvinnstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvinnstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinnstr */

#ifdef HAVE_mvinsch
/* From `/usr/include/curses.h:584'.  */
int chkr_stub_mvinsch (int arg0, int arg1, chtype arg2) __asm__ (CHKR_PREFIX ("mvinsch"));
int
chkr_stub_mvinsch (int arg0, int arg1, chtype arg2)
{
#if USE_BI_JUMP
  __builtin_jump (mvinsch);
#else
  return mvinsch (arg0, arg1, arg2);
  {
    int res;
    res = mvinsch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinsch */

#ifdef HAVE_mvinsnstr
/* From `/usr/include/curses.h:585'.  */
int chkr_stub_mvinsnstr (int arg0, int arg1, char * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvinsnstr"));
int
chkr_stub_mvinsnstr (int arg0, int arg1, char * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (char), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinsnstr);
#else
  return mvinsnstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvinsnstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinsnstr */

#ifdef HAVE_mvinsstr
/* From `/usr/include/curses.h:586'.  */
int chkr_stub_mvinsstr (int arg0, int arg1, char * arg2) __asm__ (CHKR_PREFIX ("mvinsstr"));
int
chkr_stub_mvinsstr (int arg0, int arg1, char * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (char), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinsstr);
#else
  return mvinsstr (arg0, arg1, arg2);
  {
    int res;
    res = mvinsstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinsstr */

#ifdef HAVE_mvinstr
/* From `/usr/include/curses.h:587'.  */
int chkr_stub_mvinstr (int arg0, int arg1, char * arg2) __asm__ (CHKR_PREFIX ("mvinstr"));
int
chkr_stub_mvinstr (int arg0, int arg1, char * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (char), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinstr);
#else
  return mvinstr (arg0, arg1, arg2);
  {
    int res;
    res = mvinstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinstr */

#ifdef HAVE_mvvline
/* From `/usr/include/curses.h:588'.  */
int chkr_stub_mvvline (int arg0, int arg1, chtype arg2, int arg3) __asm__ (CHKR_PREFIX ("mvvline"));
int
chkr_stub_mvvline (int arg0, int arg1, chtype arg2, int arg3)
{
#if USE_BI_JUMP
  __builtin_jump (mvvline);
#else
  return mvvline (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvvline (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvvline */

#ifdef HAVE_mvwaddch
/* From `/usr/include/curses.h:589'.  */
int chkr_stub_mvwaddch (WINDOW * arg0, int arg1, int arg2, chtype arg3) __asm__ (CHKR_PREFIX ("mvwaddch"));
int
chkr_stub_mvwaddch (WINDOW * arg0, int arg1, int arg2, chtype arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwaddch);
#else
  return mvwaddch (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwaddch (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddch */

#ifdef HAVE_mvwaddchnstr
/* From `/usr/include/curses.h:590'.  */
int chkr_stub_mvwaddchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwaddchnstr"));
int
chkr_stub_mvwaddchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddchnstr);
#else
  return mvwaddchnstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwaddchnstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddchnstr */

#ifdef HAVE_mvwaddchstr
/* From `/usr/include/curses.h:591'.  */
int chkr_stub_mvwaddchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3) __asm__ (CHKR_PREFIX ("mvwaddchstr"));
int
chkr_stub_mvwaddchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddchstr);
#else
  return mvwaddchstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwaddchstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddchstr */

#ifdef HAVE_mvwaddnstr
/* From `/usr/include/curses.h:592'.  */
int chkr_stub_mvwaddnstr (WINDOW * arg0, int arg1, int arg2, char * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwaddnstr"));
int
chkr_stub_mvwaddnstr (WINDOW * arg0, int arg1, int arg2, char * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (char), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddnstr);
#else
  return mvwaddnstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwaddnstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddnstr */

#ifdef HAVE_mvwaddstr
/* From `/usr/include/curses.h:593'.  */
int chkr_stub_mvwaddstr (WINDOW * arg0, int arg1, int arg2, char * arg3) __asm__ (CHKR_PREFIX ("mvwaddstr"));
int
chkr_stub_mvwaddstr (WINDOW * arg0, int arg1, int arg2, char * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (char), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddstr);
#else
  return mvwaddstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwaddstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddstr */

#ifdef HAVE_mvwdelch
/* From `/usr/include/curses.h:594'.  */
int chkr_stub_mvwdelch (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("mvwdelch"));
int
chkr_stub_mvwdelch (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwdelch);
#else
  return mvwdelch (arg0, arg1, arg2);
  {
    int res;
    res = mvwdelch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwdelch */

#ifdef HAVE_mvwgetch
/* From `/usr/include/curses.h:595'.  */
int chkr_stub_mvwgetch (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("mvwgetch"));
int
chkr_stub_mvwgetch (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwgetch);
#else
  return mvwgetch (arg0, arg1, arg2);
  {
    int res;
    res = mvwgetch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwgetch */

#ifdef HAVE_mvwgetstr
/* From `/usr/include/curses.h:596'.  */
int chkr_stub_mvwgetstr (WINDOW * arg0, int arg1, int arg2, char * arg3) __asm__ (CHKR_PREFIX ("mvwgetstr"));
int
chkr_stub_mvwgetstr (WINDOW * arg0, int arg1, int arg2, char * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (char), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwgetstr);
#else
  return mvwgetstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwgetstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwgetstr */

#ifdef HAVE_mvwhline
/* From `/usr/include/curses.h:597'.  */
int chkr_stub_mvwhline (WINDOW * arg0, int arg1, int arg2, chtype arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwhline"));
int
chkr_stub_mvwhline (WINDOW * arg0, int arg1, int arg2, chtype arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwhline);
#else
  return mvwhline (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwhline (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwhline */

#ifdef HAVE_mvwinchnstr
/* From `/usr/include/curses.h:598'.  */
int chkr_stub_mvwinchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwinchnstr"));
int
chkr_stub_mvwinchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinchnstr);
#else
  return mvwinchnstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwinchnstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinchnstr */

#ifdef HAVE_mvwinchstr
/* From `/usr/include/curses.h:599'.  */
int chkr_stub_mvwinchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3) __asm__ (CHKR_PREFIX ("mvwinchstr"));
int
chkr_stub_mvwinchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinchstr);
#else
  return mvwinchstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinchstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinchstr */

#ifdef HAVE_mvwinnstr
/* From `/usr/include/curses.h:600'.  */
int chkr_stub_mvwinnstr (WINDOW * arg0, int arg1, int arg2, char * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwinnstr"));
int
chkr_stub_mvwinnstr (WINDOW * arg0, int arg1, int arg2, char * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (char), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinnstr);
#else
  return mvwinnstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwinnstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinnstr */

#ifdef HAVE_mvwinsch
/* From `/usr/include/curses.h:601'.  */
int chkr_stub_mvwinsch (WINDOW * arg0, int arg1, int arg2, chtype arg3) __asm__ (CHKR_PREFIX ("mvwinsch"));
int
chkr_stub_mvwinsch (WINDOW * arg0, int arg1, int arg2, chtype arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwinsch);
#else
  return mvwinsch (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinsch (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinsch */

#ifdef HAVE_mvwinsnstr
/* From `/usr/include/curses.h:602'.  */
int chkr_stub_mvwinsnstr (WINDOW * arg0, int arg1, int arg2, char * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwinsnstr"));
int
chkr_stub_mvwinsnstr (WINDOW * arg0, int arg1, int arg2, char * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (char), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinsnstr);
#else
  return mvwinsnstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwinsnstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinsnstr */

#ifdef HAVE_mvwinsstr
/* From `/usr/include/curses.h:603'.  */
int chkr_stub_mvwinsstr (WINDOW * arg0, int arg1, int arg2, char * arg3) __asm__ (CHKR_PREFIX ("mvwinsstr"));
int
chkr_stub_mvwinsstr (WINDOW * arg0, int arg1, int arg2, char * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (char), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinsstr);
#else
  return mvwinsstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinsstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinsstr */

#ifdef HAVE_mvwinstr
/* From `/usr/include/curses.h:604'.  */
int chkr_stub_mvwinstr (WINDOW * arg0, int arg1, int arg2, char * arg3) __asm__ (CHKR_PREFIX ("mvwinstr"));
int
chkr_stub_mvwinstr (WINDOW * arg0, int arg1, int arg2, char * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (char), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinstr);
#else
  return mvwinstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinstr */

#ifdef HAVE_mvwvline
/* From `/usr/include/curses.h:605'.  */
int chkr_stub_mvwvline (WINDOW * arg0, int arg1, int arg2, chtype arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwvline"));
int
chkr_stub_mvwvline (WINDOW * arg0, int arg1, int arg2, chtype arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwvline);
#else
  return mvwvline (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwvline (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwvline */

#ifdef HAVE_nl
/* From `/usr/include/curses.h:606'.  */
int chkr_stub_nl (void ) __asm__ (CHKR_PREFIX ("nl"));
int
chkr_stub_nl (void )
{
#if USE_BI_JUMP
  __builtin_jump (nl);
#else
  return nl ();
  {
    int res;
    res = nl ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_nl */

#ifdef HAVE_nocrmode
/* From `/usr/include/curses.h:606'.  */
int chkr_stub_nocrmode (void ) __asm__ (CHKR_PREFIX ("nocrmode"));
int
chkr_stub_nocrmode (void )
{
#if USE_BI_JUMP
  __builtin_jump (nocrmode);
#else
  return nocrmode ();
  {
    int res;
    res = nocrmode ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_nocrmode */

#ifdef HAVE_nodelay
/* From `/usr/include/curses.h:607'.  */
int chkr_stub_nodelay (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("nodelay"));
int
chkr_stub_nodelay (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (nodelay);
#else
  return nodelay (arg0, arg1);
  {
    int res;
    res = nodelay (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_nodelay */

#ifdef HAVE_noecho
/* From `/usr/include/curses.h:608'.  */
int chkr_stub_noecho (void ) __asm__ (CHKR_PREFIX ("noecho"));
int
chkr_stub_noecho (void )
{
#if USE_BI_JUMP
  __builtin_jump (noecho);
#else
  return noecho ();
  {
    int res;
    res = noecho ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_noecho */

#ifdef HAVE_nonl
/* From `/usr/include/curses.h:608'.  */
int chkr_stub_nonl (void ) __asm__ (CHKR_PREFIX ("nonl"));
int
chkr_stub_nonl (void )
{
#if USE_BI_JUMP
  __builtin_jump (nonl);
#else
  return nonl ();
  {
    int res;
    res = nonl ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_nonl */

#ifdef HAVE_notimeout
/* From `/usr/include/curses.h:609'.  */
int chkr_stub_notimeout (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("notimeout"));
int
chkr_stub_notimeout (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (notimeout);
#else
  return notimeout (arg0, arg1);
  {
    int res;
    res = notimeout (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_notimeout */

#ifdef HAVE_overlay
/* From `/usr/include/curses.h:610'.  */
int chkr_stub_overlay (WINDOW * arg0, WINDOW * arg1) __asm__ (CHKR_PREFIX ("overlay"));
int
chkr_stub_overlay (WINDOW * arg0, WINDOW * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (WINDOW), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (overlay);
#else
  return overlay (arg0, arg1);
  {
    int res;
    res = overlay (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_overlay */

#ifdef HAVE_overwrite
/* From `/usr/include/curses.h:610'.  */
int chkr_stub_overwrite (WINDOW * arg0, WINDOW * arg1) __asm__ (CHKR_PREFIX ("overwrite"));
int
chkr_stub_overwrite (WINDOW * arg0, WINDOW * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (WINDOW), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (overwrite);
#else
  return overwrite (arg0, arg1);
  {
    int res;
    res = overwrite (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_overwrite */

#ifdef HAVE_redrawwin
/* From `/usr/include/curses.h:611'.  */
int chkr_stub_redrawwin (WINDOW * arg0) __asm__ (CHKR_PREFIX ("redrawwin"));
int
chkr_stub_redrawwin (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (redrawwin);
#else
  return redrawwin (arg0);
  {
    int res;
    res = redrawwin (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_redrawwin */

#ifdef HAVE_refresh
/* From `/usr/include/curses.h:611'.  */
int chkr_stub_refresh (void ) __asm__ (CHKR_PREFIX ("refresh"));
int
chkr_stub_refresh (void )
{
#if USE_BI_JUMP
  __builtin_jump (refresh);
#else
  return refresh ();
  {
    int res;
    res = refresh ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_refresh */

#ifdef HAVE_resetterm
/* From `/usr/include/curses.h:612'.  */
int chkr_stub_resetterm (void ) __asm__ (CHKR_PREFIX ("resetterm"));
int
chkr_stub_resetterm (void )
{
#if USE_BI_JUMP
  __builtin_jump (resetterm);
#else
  return resetterm ();
  {
    int res;
    res = resetterm ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_resetterm */

#ifdef HAVE_saveterm
/* From `/usr/include/curses.h:612'.  */
int chkr_stub_saveterm (void ) __asm__ (CHKR_PREFIX ("saveterm"));
int
chkr_stub_saveterm (void )
{
#if USE_BI_JUMP
  __builtin_jump (saveterm);
#else
  return saveterm ();
  {
    int res;
    res = saveterm ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_saveterm */

#ifdef HAVE_scr_init
/* From `/usr/include/curses.h:612'.  */
int chkr_stub_scr_init (char * arg0) __asm__ (CHKR_PREFIX ("scr_init"));
int
chkr_stub_scr_init (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (scr_init);
#else
  return scr_init (arg0);
  {
    int res;
    res = scr_init (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scr_init */

#ifdef HAVE_scr_restore
/* From `/usr/include/curses.h:613'.  */
int chkr_stub_scr_restore (char * arg0) __asm__ (CHKR_PREFIX ("scr_restore"));
int
chkr_stub_scr_restore (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (scr_restore);
#else
  return scr_restore (arg0);
  {
    int res;
    res = scr_restore (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scr_restore */

#ifdef HAVE_scr_set
/* From `/usr/include/curses.h:613'.  */
int chkr_stub_scr_set (char * arg0) __asm__ (CHKR_PREFIX ("scr_set"));
int
chkr_stub_scr_set (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (scr_set);
#else
  return scr_set (arg0);
  {
    int res;
    res = scr_set (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scr_set */

#ifdef HAVE_scrl
/* From `/usr/include/curses.h:613'.  */
int chkr_stub_scrl (int arg0) __asm__ (CHKR_PREFIX ("scrl"));
int
chkr_stub_scrl (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (scrl);
#else
  return scrl (arg0);
  {
    int res;
    res = scrl (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scrl */

#ifdef HAVE_scroll
/* From `/usr/include/curses.h:614'.  */
int chkr_stub_scroll (WINDOW * arg0) __asm__ (CHKR_PREFIX ("scroll"));
int
chkr_stub_scroll (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (scroll);
#else
  return scroll (arg0);
  {
    int res;
    res = scroll (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scroll */

#ifdef HAVE_scrollok
/* From `/usr/include/curses.h:615'.  */
int chkr_stub_scrollok (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("scrollok"));
int
chkr_stub_scrollok (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (scrollok);
#else
  return scrollok (arg0, arg1);
  {
    int res;
    res = scrollok (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_scrollok */

#ifdef HAVE_setscrreg
/* From `/usr/include/curses.h:616'.  */
int chkr_stub_setscrreg (int arg0, int arg1) __asm__ (CHKR_PREFIX ("setscrreg"));
int
chkr_stub_setscrreg (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (setscrreg);
#else
  return setscrreg (arg0, arg1);
  {
    int res;
    res = setscrreg (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_setscrreg */

#ifdef HAVE_setterm
/* From `/usr/include/curses.h:616'.  */
int chkr_stub_setterm (char * arg0) __asm__ (CHKR_PREFIX ("setterm"));
int
chkr_stub_setterm (char * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (char), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (setterm);
#else
  return setterm (arg0);
  {
    int res;
    res = setterm (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_setterm */

#ifdef HAVE_slk_init
/* From `/usr/include/curses.h:617'.  */
int chkr_stub_slk_init (int arg0) __asm__ (CHKR_PREFIX ("slk_init"));
int
chkr_stub_slk_init (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (slk_init);
#else
  return slk_init (arg0);
  {
    int res;
    res = slk_init (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_slk_init */

#ifdef HAVE_standend
/* From `/usr/include/curses.h:617'.  */
int chkr_stub_standend (void ) __asm__ (CHKR_PREFIX ("standend"));
int
chkr_stub_standend (void )
{
#if USE_BI_JUMP
  __builtin_jump (standend);
#else
  return standend ();
  {
    int res;
    res = standend ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_standend */

#ifdef HAVE_standout
/* From `/usr/include/curses.h:617'.  */
int chkr_stub_standout (void ) __asm__ (CHKR_PREFIX ("standout"));
int
chkr_stub_standout (void )
{
#if USE_BI_JUMP
  __builtin_jump (standout);
#else
  return standout ();
  {
    int res;
    res = standout ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_standout */

#ifdef HAVE_syncok
/* From `/usr/include/curses.h:618'.  */
int chkr_stub_syncok (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("syncok"));
int
chkr_stub_syncok (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (syncok);
#else
  return syncok (arg0, arg1);
  {
    int res;
    res = syncok (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_syncok */

#ifdef HAVE_touchline
/* From `/usr/include/curses.h:619'.  */
int chkr_stub_touchline (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("touchline"));
int
chkr_stub_touchline (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (touchline);
#else
  return touchline (arg0, arg1, arg2);
  {
    int res;
    res = touchline (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_touchline */

#ifdef HAVE_touchwin
/* From `/usr/include/curses.h:619'.  */
int chkr_stub_touchwin (WINDOW * arg0) __asm__ (CHKR_PREFIX ("touchwin"));
int
chkr_stub_touchwin (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (touchwin);
#else
  return touchwin (arg0);
  {
    int res;
    res = touchwin (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_touchwin */

#ifdef HAVE_untouchwin
/* From `/usr/include/curses.h:620'.  */
int chkr_stub_untouchwin (WINDOW * arg0) __asm__ (CHKR_PREFIX ("untouchwin"));
int
chkr_stub_untouchwin (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (untouchwin);
#else
  return untouchwin (arg0);
  {
    int res;
    res = untouchwin (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_untouchwin */

#ifdef HAVE_vline
/* From `/usr/include/curses.h:620'.  */
int chkr_stub_vline (chtype arg0, int arg1) __asm__ (CHKR_PREFIX ("vline"));
int
chkr_stub_vline (chtype arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (vline);
#else
  return vline (arg0, arg1);
  {
    int res;
    res = vline (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_vline */

#ifdef HAVE_waddchstr
/* From `/usr/include/curses.h:621'.  */
int chkr_stub_waddchstr (WINDOW * arg0, chtype * arg1) __asm__ (CHKR_PREFIX ("waddchstr"));
int
chkr_stub_waddchstr (WINDOW * arg0, chtype * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddchstr);
#else
  return waddchstr (arg0, arg1);
  {
    int res;
    res = waddchstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddchstr */

#ifdef HAVE_waddstr
/* From `/usr/include/curses.h:621'.  */
int chkr_stub_waddstr (WINDOW * arg0, char * arg1) __asm__ (CHKR_PREFIX ("waddstr"));
int
chkr_stub_waddstr (WINDOW * arg0, char * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddstr);
#else
  return waddstr (arg0, arg1);
  {
    int res;
    res = waddstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddstr */

#ifdef HAVE_wclear
/* From `/usr/include/curses.h:622'.  */
int chkr_stub_wclear (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wclear"));
int
chkr_stub_wclear (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wclear);
#else
  return wclear (arg0);
  {
    int res;
    res = wclear (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wclear */

#ifdef HAVE_wdeleteln
/* From `/usr/include/curses.h:623'.  */
int chkr_stub_wdeleteln (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wdeleteln"));
int
chkr_stub_wdeleteln (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wdeleteln);
#else
  return wdeleteln (arg0);
  {
    int res;
    res = wdeleteln (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wdeleteln */

#ifdef HAVE_werase
/* From `/usr/include/curses.h:623'.  */
int chkr_stub_werase (WINDOW * arg0) __asm__ (CHKR_PREFIX ("werase"));
int
chkr_stub_werase (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (werase);
#else
  return werase (arg0);
  {
    int res;
    res = werase (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_werase */

#ifdef HAVE_winchstr
/* From `/usr/include/curses.h:624'.  */
int chkr_stub_winchstr (WINDOW * arg0, chtype * arg1) __asm__ (CHKR_PREFIX ("winchstr"));
int
chkr_stub_winchstr (WINDOW * arg0, chtype * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winchstr);
#else
  return winchstr (arg0, arg1);
  {
    int res;
    res = winchstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winchstr */

#ifdef HAVE_winsertln
/* From `/usr/include/curses.h:624'.  */
int chkr_stub_winsertln (WINDOW * arg0) __asm__ (CHKR_PREFIX ("winsertln"));
int
chkr_stub_winsertln (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (winsertln);
#else
  return winsertln (arg0);
  {
    int res;
    res = winsertln (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winsertln */

#ifdef HAVE_winsstr
/* From `/usr/include/curses.h:625'.  */
int chkr_stub_winsstr (WINDOW * arg0, char * arg1) __asm__ (CHKR_PREFIX ("winsstr"));
int
chkr_stub_winsstr (WINDOW * arg0, char * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winsstr);
#else
  return winsstr (arg0, arg1);
  {
    int res;
    res = winsstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winsstr */

#ifdef HAVE_winstr
/* From `/usr/include/curses.h:625'.  */
int chkr_stub_winstr (WINDOW * arg0, char * arg1) __asm__ (CHKR_PREFIX ("winstr"));
int
chkr_stub_winstr (WINDOW * arg0, char * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (char), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winstr);
#else
  return winstr (arg0, arg1);
  {
    int res;
    res = winstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winstr */

#ifdef HAVE_wstandend
/* From `/usr/include/curses.h:626'.  */
int chkr_stub_wstandend (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wstandend"));
int
chkr_stub_wstandend (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wstandend);
#else
  return wstandend (arg0);
  {
    int res;
    res = wstandend (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wstandend */

#ifdef HAVE_wstandout
/* From `/usr/include/curses.h:626'.  */
int chkr_stub_wstandout (WINDOW * arg0) __asm__ (CHKR_PREFIX ("wstandout"));
int
chkr_stub_wstandout (WINDOW * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wstandout);
#else
  return wstandout (arg0);
  {
    int res;
    res = wstandout (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wstandout */

#ifdef HAVE_bkgdset
/* From `/usr/include/curses.h:628'.  */
void chkr_stub_bkgdset (chtype arg0) __asm__ (CHKR_PREFIX ("bkgdset"));
void
chkr_stub_bkgdset (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (bkgdset);
#else
  bkgdset (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_bkgdset */

#ifdef HAVE_idcok
/* From `/usr/include/curses.h:628'.  */
void chkr_stub_idcok (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("idcok"));
void
chkr_stub_idcok (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (idcok);
#else
  idcok (arg0, arg1);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_idcok */

#ifdef HAVE_noqiflush
/* From `/usr/include/curses.h:629'.  */
void chkr_stub_noqiflush (void ) __asm__ (CHKR_PREFIX ("noqiflush"));
void
chkr_stub_noqiflush (void )
{
#if USE_BI_JUMP
  __builtin_jump (noqiflush);
#else
  noqiflush ();
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_noqiflush */

#ifdef HAVE_wbkgdset
/* From `/usr/include/curses.h:630'.  */
void chkr_stub_wbkgdset (WINDOW * arg0, chtype arg1) __asm__ (CHKR_PREFIX ("wbkgdset"));
void
chkr_stub_wbkgdset (WINDOW * arg0, chtype arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wbkgdset);
#else
  wbkgdset (arg0, arg1);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wbkgdset */

#ifdef HAVE_qiflush
/* From `/usr/include/curses.h:631'.  */
void chkr_stub_qiflush (void ) __asm__ (CHKR_PREFIX ("qiflush"));
void
chkr_stub_qiflush (void )
{
#if USE_BI_JUMP
  __builtin_jump (qiflush);
#else
  qiflush ();
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_qiflush */

#ifdef HAVE_timeout
/* From `/usr/include/curses.h:631'.  */
void chkr_stub_timeout (int arg0) __asm__ (CHKR_PREFIX ("timeout"));
void
chkr_stub_timeout (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (timeout);
#else
  timeout (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_timeout */

#ifdef HAVE_wtimeout
/* From `/usr/include/curses.h:631'.  */
void chkr_stub_wtimeout (WINDOW * arg0, int arg1) __asm__ (CHKR_PREFIX ("wtimeout"));
void
chkr_stub_wtimeout (WINDOW * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (wtimeout);
#else
  wtimeout (arg0, arg1);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_wtimeout */

#ifdef HAVE_use_env
/* From `/usr/include/curses.h:632'.  */
void chkr_stub_use_env (int arg0) __asm__ (CHKR_PREFIX ("use_env"));
void
chkr_stub_use_env (int arg0)
{
#if USE_BI_JUMP
  __builtin_jump (use_env);
#else
  use_env (arg0);
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_use_env */

#ifdef HAVE_inwch
/* From `/usr/include/curses.h:634'.  */
chtype chkr_stub_inwch (void ) __asm__ (CHKR_PREFIX ("inwch"));
chtype
chkr_stub_inwch (void )
{
#if USE_BI_JUMP
  __builtin_jump (inwch);
#else
  return inwch ();
  {
    chtype res;
    res = inwch ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inwch */

#ifdef HAVE_mvinwch
/* From `/usr/include/curses.h:635'.  */
chtype chkr_stub_mvinwch (int arg0, int arg1) __asm__ (CHKR_PREFIX ("mvinwch"));
chtype
chkr_stub_mvinwch (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (mvinwch);
#else
  return mvinwch (arg0, arg1);
  {
    chtype res;
    res = mvinwch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinwch */

#ifdef HAVE_mvwinwch
/* From `/usr/include/curses.h:636'.  */
chtype chkr_stub_mvwinwch (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("mvwinwch"));
chtype
chkr_stub_mvwinwch (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwinwch);
#else
  return mvwinwch (arg0, arg1, arg2);
  {
    chtype res;
    res = mvwinwch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinwch */

#ifdef HAVE_addnwstr
/* From `/usr/include/curses.h:638'.  */
int chkr_stub_addnwstr (wchar_t * arg0, int arg1) __asm__ (CHKR_PREFIX ("addnwstr"));
int
chkr_stub_addnwstr (wchar_t * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addnwstr);
#else
  return addnwstr (arg0, arg1);
  {
    int res;
    res = addnwstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addnwstr */

#ifdef HAVE_addwch
/* From `/usr/include/curses.h:639'.  */
int chkr_stub_addwch (chtype arg0) __asm__ (CHKR_PREFIX ("addwch"));
int
chkr_stub_addwch (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (addwch);
#else
  return addwch (arg0);
  {
    int res;
    res = addwch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addwch */

#ifdef HAVE_addwchnstr
/* From `/usr/include/curses.h:640'.  */
int chkr_stub_addwchnstr (chtype * arg0, int arg1) __asm__ (CHKR_PREFIX ("addwchnstr"));
int
chkr_stub_addwchnstr (chtype * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addwchnstr);
#else
  return addwchnstr (arg0, arg1);
  {
    int res;
    res = addwchnstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addwchnstr */

#ifdef HAVE_addwchstr
/* From `/usr/include/curses.h:641'.  */
int chkr_stub_addwchstr (chtype * arg0) __asm__ (CHKR_PREFIX ("addwchstr"));
int
chkr_stub_addwchstr (chtype * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addwchstr);
#else
  return addwchstr (arg0);
  {
    int res;
    res = addwchstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addwchstr */

#ifdef HAVE_addwstr
/* From `/usr/include/curses.h:642'.  */
int chkr_stub_addwstr (wchar_t * arg0) __asm__ (CHKR_PREFIX ("addwstr"));
int
chkr_stub_addwstr (wchar_t * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (addwstr);
#else
  return addwstr (arg0);
  {
    int res;
    res = addwstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_addwstr */

#ifdef HAVE_echowchar
/* From `/usr/include/curses.h:643'.  */
int chkr_stub_echowchar (chtype arg0) __asm__ (CHKR_PREFIX ("echowchar"));
int
chkr_stub_echowchar (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (echowchar);
#else
  return echowchar (arg0);
  {
    int res;
    res = echowchar (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_echowchar */

#ifdef HAVE_getnwstr
/* From `/usr/include/curses.h:644'.  */
int chkr_stub_getnwstr (wchar_t * arg0, int arg1) __asm__ (CHKR_PREFIX ("getnwstr"));
int
chkr_stub_getnwstr (wchar_t * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getnwstr);
#else
  return getnwstr (arg0, arg1);
  {
    int res;
    res = getnwstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getnwstr */

#ifdef HAVE_getwch
/* From `/usr/include/curses.h:645'.  */
int chkr_stub_getwch (void ) __asm__ (CHKR_PREFIX ("getwch"));
int
chkr_stub_getwch (void )
{
#if USE_BI_JUMP
  __builtin_jump (getwch);
#else
  return getwch ();
  {
    int res;
    res = getwch ();
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getwch */

#ifdef HAVE_getwstr
/* From `/usr/include/curses.h:646'.  */
int chkr_stub_getwstr (wchar_t * arg0) __asm__ (CHKR_PREFIX ("getwstr"));
int
chkr_stub_getwstr (wchar_t * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (getwstr);
#else
  return getwstr (arg0);
  {
    int res;
    res = getwstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_getwstr */

#ifdef HAVE_innwstr
/* From `/usr/include/curses.h:647'.  */
int chkr_stub_innwstr (wchar_t * arg0, int arg1) __asm__ (CHKR_PREFIX ("innwstr"));
int
chkr_stub_innwstr (wchar_t * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (innwstr);
#else
  return innwstr (arg0, arg1);
  {
    int res;
    res = innwstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_innwstr */

#ifdef HAVE_insnwstr
/* From `/usr/include/curses.h:648'.  */
int chkr_stub_insnwstr (wchar_t * arg0, int arg1) __asm__ (CHKR_PREFIX ("insnwstr"));
int
chkr_stub_insnwstr (wchar_t * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (insnwstr);
#else
  return insnwstr (arg0, arg1);
  {
    int res;
    res = insnwstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_insnwstr */

#ifdef HAVE_inswch
/* From `/usr/include/curses.h:649'.  */
int chkr_stub_inswch (chtype arg0) __asm__ (CHKR_PREFIX ("inswch"));
int
chkr_stub_inswch (chtype arg0)
{
#if USE_BI_JUMP
  __builtin_jump (inswch);
#else
  return inswch (arg0);
  {
    int res;
    res = inswch (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inswch */

#ifdef HAVE_inswstr
/* From `/usr/include/curses.h:650'.  */
int chkr_stub_inswstr (wchar_t * arg0) __asm__ (CHKR_PREFIX ("inswstr"));
int
chkr_stub_inswstr (wchar_t * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (inswstr);
#else
  return inswstr (arg0);
  {
    int res;
    res = inswstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inswstr */

#ifdef HAVE_inwchnstr
/* From `/usr/include/curses.h:651'.  */
int chkr_stub_inwchnstr (chtype * arg0, int arg1) __asm__ (CHKR_PREFIX ("inwchnstr"));
int
chkr_stub_inwchnstr (chtype * arg0, int arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (inwchnstr);
#else
  return inwchnstr (arg0, arg1);
  {
    int res;
    res = inwchnstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inwchnstr */

#ifdef HAVE_inwchstr
/* From `/usr/include/curses.h:652'.  */
int chkr_stub_inwchstr (chtype * arg0) __asm__ (CHKR_PREFIX ("inwchstr"));
int
chkr_stub_inwchstr (chtype * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (chtype), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (inwchstr);
#else
  return inwchstr (arg0);
  {
    int res;
    res = inwchstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inwchstr */

#ifdef HAVE_inwstr
/* From `/usr/include/curses.h:653'.  */
int chkr_stub_inwstr (wchar_t * arg0) __asm__ (CHKR_PREFIX ("inwstr"));
int
chkr_stub_inwstr (wchar_t * arg0)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (wchar_t), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (inwstr);
#else
  return inwstr (arg0);
  {
    int res;
    res = inwstr (arg0);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_inwstr */

#ifdef HAVE_mvaddnwstr
/* From `/usr/include/curses.h:654'.  */
int chkr_stub_mvaddnwstr (int arg0, int arg1, wchar_t * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvaddnwstr"));
int
chkr_stub_mvaddnwstr (int arg0, int arg1, wchar_t * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddnwstr);
#else
  return mvaddnwstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvaddnwstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddnwstr */

#ifdef HAVE_mvaddwch
/* From `/usr/include/curses.h:655'.  */
int chkr_stub_mvaddwch (int arg0, int arg1, chtype arg2) __asm__ (CHKR_PREFIX ("mvaddwch"));
int
chkr_stub_mvaddwch (int arg0, int arg1, chtype arg2)
{
#if USE_BI_JUMP
  __builtin_jump (mvaddwch);
#else
  return mvaddwch (arg0, arg1, arg2);
  {
    int res;
    res = mvaddwch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddwch */

#ifdef HAVE_mvaddwchnstr
/* From `/usr/include/curses.h:656'.  */
int chkr_stub_mvaddwchnstr (int arg0, int arg1, chtype * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvaddwchnstr"));
int
chkr_stub_mvaddwchnstr (int arg0, int arg1, chtype * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddwchnstr);
#else
  return mvaddwchnstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvaddwchnstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddwchnstr */

#ifdef HAVE_mvaddwchstr
/* From `/usr/include/curses.h:657'.  */
int chkr_stub_mvaddwchstr (int arg0, int arg1, chtype * arg2) __asm__ (CHKR_PREFIX ("mvaddwchstr"));
int
chkr_stub_mvaddwchstr (int arg0, int arg1, chtype * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddwchstr);
#else
  return mvaddwchstr (arg0, arg1, arg2);
  {
    int res;
    res = mvaddwchstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddwchstr */

#ifdef HAVE_mvaddwstr
/* From `/usr/include/curses.h:658'.  */
int chkr_stub_mvaddwstr (int arg0, int arg1, wchar_t * arg2) __asm__ (CHKR_PREFIX ("mvaddwstr"));
int
chkr_stub_mvaddwstr (int arg0, int arg1, wchar_t * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvaddwstr);
#else
  return mvaddwstr (arg0, arg1, arg2);
  {
    int res;
    res = mvaddwstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvaddwstr */

#ifdef HAVE_mvgetnwstr
/* From `/usr/include/curses.h:659'.  */
int chkr_stub_mvgetnwstr (int arg0, int arg1, wchar_t * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvgetnwstr"));
int
chkr_stub_mvgetnwstr (int arg0, int arg1, wchar_t * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvgetnwstr);
#else
  return mvgetnwstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvgetnwstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvgetnwstr */

#ifdef HAVE_mvgetwch
/* From `/usr/include/curses.h:660'.  */
int chkr_stub_mvgetwch (int arg0, int arg1) __asm__ (CHKR_PREFIX ("mvgetwch"));
int
chkr_stub_mvgetwch (int arg0, int arg1)
{
#if USE_BI_JUMP
  __builtin_jump (mvgetwch);
#else
  return mvgetwch (arg0, arg1);
  {
    int res;
    res = mvgetwch (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvgetwch */

#ifdef HAVE_mvgetwstr
/* From `/usr/include/curses.h:661'.  */
int chkr_stub_mvgetwstr (int arg0, int arg1, wchar_t * arg2) __asm__ (CHKR_PREFIX ("mvgetwstr"));
int
chkr_stub_mvgetwstr (int arg0, int arg1, wchar_t * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvgetwstr);
#else
  return mvgetwstr (arg0, arg1, arg2);
  {
    int res;
    res = mvgetwstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvgetwstr */

#ifdef HAVE_mvinnwstr
/* From `/usr/include/curses.h:662'.  */
int chkr_stub_mvinnwstr (int arg0, int arg1, wchar_t * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvinnwstr"));
int
chkr_stub_mvinnwstr (int arg0, int arg1, wchar_t * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinnwstr);
#else
  return mvinnwstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvinnwstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinnwstr */

#ifdef HAVE_mvinsnwstr
/* From `/usr/include/curses.h:663'.  */
int chkr_stub_mvinsnwstr (int arg0, int arg1, wchar_t * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvinsnwstr"));
int
chkr_stub_mvinsnwstr (int arg0, int arg1, wchar_t * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinsnwstr);
#else
  return mvinsnwstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvinsnwstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinsnwstr */

#ifdef HAVE_mvinswch
/* From `/usr/include/curses.h:664'.  */
int chkr_stub_mvinswch (int arg0, int arg1, chtype arg2) __asm__ (CHKR_PREFIX ("mvinswch"));
int
chkr_stub_mvinswch (int arg0, int arg1, chtype arg2)
{
#if USE_BI_JUMP
  __builtin_jump (mvinswch);
#else
  return mvinswch (arg0, arg1, arg2);
  {
    int res;
    res = mvinswch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinswch */

#ifdef HAVE_mvinswstr
/* From `/usr/include/curses.h:665'.  */
int chkr_stub_mvinswstr (int arg0, int arg1, wchar_t * arg2) __asm__ (CHKR_PREFIX ("mvinswstr"));
int
chkr_stub_mvinswstr (int arg0, int arg1, wchar_t * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinswstr);
#else
  return mvinswstr (arg0, arg1, arg2);
  {
    int res;
    res = mvinswstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinswstr */

#ifdef HAVE_mvinwchnstr
/* From `/usr/include/curses.h:666'.  */
int chkr_stub_mvinwchnstr (int arg0, int arg1, chtype * arg2, int arg3) __asm__ (CHKR_PREFIX ("mvinwchnstr"));
int
chkr_stub_mvinwchnstr (int arg0, int arg1, chtype * arg2, int arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinwchnstr);
#else
  return mvinwchnstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvinwchnstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinwchnstr */

#ifdef HAVE_mvinwchstr
/* From `/usr/include/curses.h:667'.  */
int chkr_stub_mvinwchstr (int arg0, int arg1, chtype * arg2) __asm__ (CHKR_PREFIX ("mvinwchstr"));
int
chkr_stub_mvinwchstr (int arg0, int arg1, chtype * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (chtype), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinwchstr);
#else
  return mvinwchstr (arg0, arg1, arg2);
  {
    int res;
    res = mvinwchstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinwchstr */

#ifdef HAVE_mvinwstr
/* From `/usr/include/curses.h:668'.  */
int chkr_stub_mvinwstr (int arg0, int arg1, wchar_t * arg2) __asm__ (CHKR_PREFIX ("mvinwstr"));
int
chkr_stub_mvinwstr (int arg0, int arg1, wchar_t * arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg2, sizeof (wchar_t), CHKR_XX, "arg2");
#if USE_BI_JUMP
  __builtin_jump (mvinwstr);
#else
  return mvinwstr (arg0, arg1, arg2);
  {
    int res;
    res = mvinwstr (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvinwstr */

#ifdef HAVE_mvwaddnwstr
/* From `/usr/include/curses.h:669'.  */
int chkr_stub_mvwaddnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwaddnwstr"));
int
chkr_stub_mvwaddnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddnwstr);
#else
  return mvwaddnwstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwaddnwstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddnwstr */

#ifdef HAVE_mvwaddwch
/* From `/usr/include/curses.h:670'.  */
int chkr_stub_mvwaddwch (WINDOW * arg0, int arg1, int arg2, chtype arg3) __asm__ (CHKR_PREFIX ("mvwaddwch"));
int
chkr_stub_mvwaddwch (WINDOW * arg0, int arg1, int arg2, chtype arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwaddwch);
#else
  return mvwaddwch (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwaddwch (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddwch */

#ifdef HAVE_mvwaddwchnstr
/* From `/usr/include/curses.h:671'.  */
int chkr_stub_mvwaddwchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwaddwchnstr"));
int
chkr_stub_mvwaddwchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddwchnstr);
#else
  return mvwaddwchnstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwaddwchnstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddwchnstr */

#ifdef HAVE_mvwaddwchstr
/* From `/usr/include/curses.h:672'.  */
int chkr_stub_mvwaddwchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3) __asm__ (CHKR_PREFIX ("mvwaddwchstr"));
int
chkr_stub_mvwaddwchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddwchstr);
#else
  return mvwaddwchstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwaddwchstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddwchstr */

#ifdef HAVE_mvwaddwstr
/* From `/usr/include/curses.h:673'.  */
int chkr_stub_mvwaddwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3) __asm__ (CHKR_PREFIX ("mvwaddwstr"));
int
chkr_stub_mvwaddwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwaddwstr);
#else
  return mvwaddwstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwaddwstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwaddwstr */

#ifdef HAVE_mvwgetnwstr
/* From `/usr/include/curses.h:674'.  */
int chkr_stub_mvwgetnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwgetnwstr"));
int
chkr_stub_mvwgetnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwgetnwstr);
#else
  return mvwgetnwstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwgetnwstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwgetnwstr */

#ifdef HAVE_mvwgetwch
/* From `/usr/include/curses.h:675'.  */
int chkr_stub_mvwgetwch (WINDOW * arg0, int arg1, int arg2) __asm__ (CHKR_PREFIX ("mvwgetwch"));
int
chkr_stub_mvwgetwch (WINDOW * arg0, int arg1, int arg2)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwgetwch);
#else
  return mvwgetwch (arg0, arg1, arg2);
  {
    int res;
    res = mvwgetwch (arg0, arg1, arg2);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwgetwch */

#ifdef HAVE_mvwgetwstr
/* From `/usr/include/curses.h:676'.  */
int chkr_stub_mvwgetwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3) __asm__ (CHKR_PREFIX ("mvwgetwstr"));
int
chkr_stub_mvwgetwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwgetwstr);
#else
  return mvwgetwstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwgetwstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwgetwstr */

#ifdef HAVE_mvwinnwstr
/* From `/usr/include/curses.h:677'.  */
int chkr_stub_mvwinnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwinnwstr"));
int
chkr_stub_mvwinnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinnwstr);
#else
  return mvwinnwstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwinnwstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinnwstr */

#ifdef HAVE_mvwinsnwstr
/* From `/usr/include/curses.h:678'.  */
int chkr_stub_mvwinsnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwinsnwstr"));
int
chkr_stub_mvwinsnwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinsnwstr);
#else
  return mvwinsnwstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwinsnwstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinsnwstr */

#ifdef HAVE_mvwinswch
/* From `/usr/include/curses.h:679'.  */
int chkr_stub_mvwinswch (WINDOW * arg0, int arg1, int arg2, chtype arg3) __asm__ (CHKR_PREFIX ("mvwinswch"));
int
chkr_stub_mvwinswch (WINDOW * arg0, int arg1, int arg2, chtype arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
#if USE_BI_JUMP
  __builtin_jump (mvwinswch);
#else
  return mvwinswch (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinswch (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinswch */

#ifdef HAVE_mvwinswstr
/* From `/usr/include/curses.h:680'.  */
int chkr_stub_mvwinswstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3) __asm__ (CHKR_PREFIX ("mvwinswstr"));
int
chkr_stub_mvwinswstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinswstr);
#else
  return mvwinswstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinswstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinswstr */

#ifdef HAVE_mvwinwchnstr
/* From `/usr/include/curses.h:681'.  */
int chkr_stub_mvwinwchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4) __asm__ (CHKR_PREFIX ("mvwinwchnstr"));
int
chkr_stub_mvwinwchnstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3, int arg4)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinwchnstr);
#else
  return mvwinwchnstr (arg0, arg1, arg2, arg3, arg4);
  {
    int res;
    res = mvwinwchnstr (arg0, arg1, arg2, arg3, arg4);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinwchnstr */

#ifdef HAVE_mvwinwchstr
/* From `/usr/include/curses.h:682'.  */
int chkr_stub_mvwinwchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3) __asm__ (CHKR_PREFIX ("mvwinwchstr"));
int
chkr_stub_mvwinwchstr (WINDOW * arg0, int arg1, int arg2, chtype * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (chtype), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinwchstr);
#else
  return mvwinwchstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinwchstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinwchstr */

#ifdef HAVE_mvwinwstr
/* From `/usr/include/curses.h:683'.  */
int chkr_stub_mvwinwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3) __asm__ (CHKR_PREFIX ("mvwinwstr"));
int
chkr_stub_mvwinwstr (WINDOW * arg0, int arg1, int arg2, wchar_t * arg3)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg3, sizeof (wchar_t), CHKR_XX, "arg3");
#if USE_BI_JUMP
  __builtin_jump (mvwinwstr);
#else
  return mvwinwstr (arg0, arg1, arg2, arg3);
  {
    int res;
    res = mvwinwstr (arg0, arg1, arg2, arg3);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_mvwinwstr */

#ifdef HAVE_waddwchstr
/* From `/usr/include/curses.h:684'.  */
int chkr_stub_waddwchstr (WINDOW * arg0, chtype * arg1) __asm__ (CHKR_PREFIX ("waddwchstr"));
int
chkr_stub_waddwchstr (WINDOW * arg0, chtype * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddwchstr);
#else
  return waddwchstr (arg0, arg1);
  {
    int res;
    res = waddwchstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddwchstr */

#ifdef HAVE_waddwstr
/* From `/usr/include/curses.h:685'.  */
int chkr_stub_waddwstr (WINDOW * arg0, wchar_t * arg1) __asm__ (CHKR_PREFIX ("waddwstr"));
int
chkr_stub_waddwstr (WINDOW * arg0, wchar_t * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (waddwstr);
#else
  return waddwstr (arg0, arg1);
  {
    int res;
    res = waddwstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_waddwstr */

#ifdef HAVE_winswstr
/* From `/usr/include/curses.h:686'.  */
int chkr_stub_winswstr (WINDOW * arg0, wchar_t * arg1) __asm__ (CHKR_PREFIX ("winswstr"));
int
chkr_stub_winswstr (WINDOW * arg0, wchar_t * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (wchar_t), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winswstr);
#else
  return winswstr (arg0, arg1);
  {
    int res;
    res = winswstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winswstr */

#ifdef HAVE_winwchstr
/* From `/usr/include/curses.h:687'.  */
int chkr_stub_winwchstr (WINDOW * arg0, chtype * arg1) __asm__ (CHKR_PREFIX ("winwchstr"));
int
chkr_stub_winwchstr (WINDOW * arg0, chtype * arg1)
{
  /* This function requires a stub */
  stubs_chkr_check_addr (arg0, sizeof (WINDOW), CHKR_XX, "arg0");
  stubs_chkr_check_addr (arg1, sizeof (chtype), CHKR_XX, "arg1");
#if USE_BI_JUMP
  __builtin_jump (winwchstr);
#else
  return winwchstr (arg0, arg1);
  {
    int res;
    res = winwchstr (arg0, arg1);
    return res;
  }
#endif /* !USE_BI_JUMP */
}
#endif /* HAVE_winwchstr */

