/* This file was generated by ./base/MKlib_gen.sh implemented */

/*
 * DO NOT EDIT THIS FILE BY HAND!
 */
#define NCURSES_ATTR_T int
#include <ncurses_cfg.h>

#undef NCURSES_NOMACROS /* _this_ file uses macros */
#define NCURSES_NOMACROS 1

#include <curses.priv.h>



extern int call_addch (const chtype z);
int call_addch (const chtype z)
{
	T((T_CALLED("addch(%s)"), _tracechtype2(0,z)));
	returnCode(addch(z));
}



extern int call_addchnstr (const chtype * a1, int z);
int call_addchnstr (const chtype * a1, int z)
{
	T((T_CALLED("addchnstr(%p,%d)"), (const void *)a1, z));
	returnCode(addchnstr(a1, z));
}



extern int call_addchstr (const chtype * z);
int call_addchstr (const chtype * z)
{
	T((T_CALLED("addchstr(%p)"), (const void *)z));
	returnCode(addchstr(z));
}



extern int call_addnstr (const char * a1, int z);
int call_addnstr (const char * a1, int z)
{
	T((T_CALLED("addnstr(%s,%d)"), _nc_visbuf2(0,a1), z));
	returnCode(addnstr(a1, z));
}



extern int call_addstr (const char * z);
int call_addstr (const char * z)
{
	T((T_CALLED("addstr(%s)"), _nc_visbuf2(0,z)));
	returnCode(addstr(z));
}



extern int call_attroff (int z);
int call_attroff (int z)
{
	T((T_CALLED("attroff(%s)"), _traceattr2(0,(chtype)z)));
	returnCode(attroff(z));
}



extern int call_attron (int z);
int call_attron (int z)
{
	T((T_CALLED("attron(%s)"), _traceattr2(0,(chtype)z)));
	returnCode(attron(z));
}



extern int call_attrset (int z);
int call_attrset (int z)
{
	T((T_CALLED("attrset(%s)"), _traceattr2(0,(chtype)z)));
	returnIntAttr((attr_t)attrset(z));
}



extern int call_attr_get (attr_t * a1, short * a2, void * z);
int call_attr_get (attr_t * a1, short * a2, void * z)
{
	T((T_CALLED("attr_get(%p,%p,%p)"), (const void *)a1, (const void *)a2, (const void *)z));
	returnCode(attr_get(a1, a2, z));
}



extern int call_attr_off (attr_t a1, void * z);
int call_attr_off (attr_t a1, void * z)
{
	T((T_CALLED("attr_off(%s,%p)"), _traceattr2(0,a1), (const void *)z));
	returnCode(attr_off(a1, z));
}



extern int call_attr_on (attr_t a1, void * z);
int call_attr_on (attr_t a1, void * z)
{
	T((T_CALLED("attr_on(%s,%p)"), _traceattr2(0,a1), (const void *)z));
	returnCode(attr_on(a1, z));
}



extern int call_attr_set (attr_t a1, short a2, void * z);
int call_attr_set (attr_t a1, short a2, void * z)
{
	T((T_CALLED("attr_set(%s,%#lx,%p)"), _traceattr2(0,a1), (long)a2, (const void *)z));
	returnCode(attr_set(a1, a2, z));
}



extern int call_baudrate (void);
int call_baudrate (void)
{
	T((T_CALLED("baudrate()")));
	returnCode(baudrate());
}



extern int call_beep (void);
int call_beep (void)
{
	T((T_CALLED("beep()")));
	returnCode(beep());
}



extern int call_bkgd (chtype z);
int call_bkgd (chtype z)
{
	T((T_CALLED("bkgd(%s)"), _tracechtype2(0,z)));
	returnCode(bkgd(z));
}



extern void call_bkgdset (chtype z);
void call_bkgdset (chtype z)
{
	T((T_CALLED("bkgdset(%s)"), _tracechtype2(0,z)));
	bkgdset(z);
	returnVoid;
}



extern int call_border (chtype a1, chtype a2, chtype a3, chtype a4, chtype a5, chtype a6, chtype a7, chtype z);
int call_border (chtype a1, chtype a2, chtype a3, chtype a4, chtype a5, chtype a6, chtype a7, chtype z)
{
	T((T_CALLED("border(%s,%s,%s,%s,%s,%s,%s,%s)"), _tracechtype2(0,a1), _tracechtype2(1,a2), _tracechtype2(2,a3), _tracechtype2(3,a4), _tracechtype2(4,a5), _tracechtype2(5,a6), _tracechtype2(6,a7), _tracechtype2(7,z)));
	returnCode(border(a1, a2, a3, a4, a5, a6, a7, z));
}



extern int call_box (WINDOW * a1, chtype a2, chtype z);
int call_box (WINDOW * a1, chtype a2, chtype z)
{
	T((T_CALLED("box(%p,%s,%s)"), (const void *)a1, _tracechtype2(1,a2), _tracechtype2(2,z)));
	returnCode(box(a1, a2, z));
}



extern NCURSES_BOOL call_can_change_color (void);
NCURSES_BOOL call_can_change_color (void)
{
	T((T_CALLED("can_change_color()")));
	returnBool(can_change_color());
}



extern int call_cbreak (void);
int call_cbreak (void)
{
	T((T_CALLED("cbreak()")));
	returnCode(cbreak());
}



extern int call_chgat (int a1, attr_t a2, short a3, const void * z);
int call_chgat (int a1, attr_t a2, short a3, const void * z)
{
	T((T_CALLED("chgat(%d,%s,%#lx,%p)"), a1, _traceattr2(1,a2), (long)a3, (const void *)z));
	returnCode(chgat(a1, a2, a3, z));
}



extern int call_clear (void);
int call_clear (void)
{
	T((T_CALLED("clear()")));
	returnCode(clear());
}



extern int call_clearok (WINDOW * a1, NCURSES_BOOL z);
int call_clearok (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("clearok(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(clearok(a1, z));
}



extern int call_clrtobot (void);
int call_clrtobot (void)
{
	T((T_CALLED("clrtobot()")));
	returnCode(clrtobot());
}



extern int call_clrtoeol (void);
int call_clrtoeol (void)
{
	T((T_CALLED("clrtoeol()")));
	returnCode(clrtoeol());
}



extern int call_color_content (short a1, short * a2, short * a3, short * z);
int call_color_content (short a1, short * a2, short * a3, short * z)
{
	T((T_CALLED("color_content(%#lx,%p,%p,%p)"), (long)a1, (const void *)a2, (const void *)a3, (const void *)z));
	returnCode(color_content(a1, a2, a3, z));
}



extern int call_color_set (short a1, void * z);
int call_color_set (short a1, void * z)
{
	T((T_CALLED("color_set(%#lx,%p)"), (long)a1, (const void *)z));
	returnCode(color_set(a1, z));
}



extern int call_COLOR_PAIR (int z);
int call_COLOR_PAIR (int z)
{
	T((T_CALLED("COLOR_PAIR(%d)"), z));
	returnCode(COLOR_PAIR(z));
}



extern int call_copywin (const WINDOW * a1, WINDOW * a2, int a3, int a4, int a5, int a6, int a7, int a8, int z);
int call_copywin (const WINDOW * a1, WINDOW * a2, int a3, int a4, int a5, int a6, int a7, int a8, int z)
{
	T((T_CALLED("copywin(%p,%p,%d,%d,%d,%d,%d,%d,%d)"), (const void *)a1, (const void *)a2, a3, a4, a5, a6, a7, a8, z));
	returnCode(copywin(a1, a2, a3, a4, a5, a6, a7, a8, z));
}



extern int call_curs_set (int z);
int call_curs_set (int z)
{
	T((T_CALLED("curs_set(%d)"), z));
	returnCode(curs_set(z));
}



extern int call_def_prog_mode (void);
int call_def_prog_mode (void)
{
	T((T_CALLED("def_prog_mode()")));
	returnCode(def_prog_mode());
}



extern int call_def_shell_mode (void);
int call_def_shell_mode (void)
{
	T((T_CALLED("def_shell_mode()")));
	returnCode(def_shell_mode());
}



extern int call_delay_output (int z);
int call_delay_output (int z)
{
	T((T_CALLED("delay_output(%d)"), z));
	returnCode(delay_output(z));
}



extern int call_delch (void);
int call_delch (void)
{
	T((T_CALLED("delch()")));
	returnCode(delch());
}



extern void call_delscreen (struct screen * z);
void call_delscreen (struct screen * z)
{
	T((T_CALLED("delscreen(%p)"), (const void *)z));
	delscreen(z);
	returnVoid;
}



extern int call_delwin (WINDOW * z);
int call_delwin (WINDOW * z)
{
	T((T_CALLED("delwin(%p)"), (const void *)z));
	returnCode(delwin(z));
}



extern int call_deleteln (void);
int call_deleteln (void)
{
	T((T_CALLED("deleteln()")));
	returnCode(deleteln());
}



extern WINDOW * call_derwin (WINDOW * a1, int a2, int a3, int a4, int z);
WINDOW * call_derwin (WINDOW * a1, int a2, int a3, int a4, int z)
{
	T((T_CALLED("derwin(%p,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, z));
	returnWin(derwin(a1, a2, a3, a4, z));
}



extern int call_doupdate (void);
int call_doupdate (void)
{
	T((T_CALLED("doupdate()")));
	returnCode(doupdate());
}



extern WINDOW * call_dupwin (WINDOW * z);
WINDOW * call_dupwin (WINDOW * z)
{
	T((T_CALLED("dupwin(%p)"), (const void *)z));
	returnWin(dupwin(z));
}



extern int call_echo (void);
int call_echo (void)
{
	T((T_CALLED("echo()")));
	returnCode(echo());
}



extern int call_echochar (const chtype z);
int call_echochar (const chtype z)
{
	T((T_CALLED("echochar(%s)"), _tracechtype2(0,z)));
	returnCode(echochar(z));
}



extern int call_erase (void);
int call_erase (void)
{
	T((T_CALLED("erase()")));
	returnCode(erase());
}



extern int call_endwin (void);
int call_endwin (void)
{
	T((T_CALLED("endwin()")));
	returnCode(endwin());
}



extern char call_erasechar (void);
char call_erasechar (void)
{
	T((T_CALLED("erasechar()")));
	returnCode(erasechar());
}



extern void call_filter (void);
void call_filter (void)
{
	T((T_CALLED("filter()")));
	filter();
	returnVoid;
}



extern int call_flash (void);
int call_flash (void)
{
	T((T_CALLED("flash()")));
	returnCode(flash());
}



extern int call_flushinp (void);
int call_flushinp (void)
{
	T((T_CALLED("flushinp()")));
	returnCode(flushinp());
}



extern chtype call_getbkgd (WINDOW * z);
chtype call_getbkgd (WINDOW * z)
{
	T((T_CALLED("getbkgd(%p)"), (const void *)z));
	returnChtype(getbkgd(z));
}



extern int call_getch (void);
int call_getch (void)
{
	T((T_CALLED("getch()")));
	returnCode(getch());
}



extern int call_getnstr (char * a1, int z);
int call_getnstr (char * a1, int z)
{
	T((T_CALLED("getnstr(%p,%d)"), _nc_visbuf2(0,a1), z));
	returnCode(getnstr(a1, z));
}



extern int call_getstr (char * z);
int call_getstr (char * z)
{
	T((T_CALLED("getstr(%p)"), _nc_visbuf2(0,z)));
	returnCode(getstr(z));
}



extern WINDOW * call_getwin (FILE * z);
WINDOW * call_getwin (FILE * z)
{
	T((T_CALLED("getwin(%p)"), (const void *)z));
	returnWin(getwin(z));
}



extern int call_halfdelay (int z);
int call_halfdelay (int z)
{
	T((T_CALLED("halfdelay(%d)"), z));
	returnCode(halfdelay(z));
}



extern NCURSES_BOOL call_has_colors (void);
NCURSES_BOOL call_has_colors (void)
{
	T((T_CALLED("has_colors()")));
	returnBool(has_colors());
}



extern NCURSES_BOOL call_has_ic (void);
NCURSES_BOOL call_has_ic (void)
{
	T((T_CALLED("has_ic()")));
	returnBool(has_ic());
}



extern NCURSES_BOOL call_has_il (void);
NCURSES_BOOL call_has_il (void)
{
	T((T_CALLED("has_il()")));
	returnBool(has_il());
}



extern int call_hline (chtype a1, int z);
int call_hline (chtype a1, int z)
{
	T((T_CALLED("hline(%s,%d)"), _tracechtype2(0,a1), z));
	returnCode(hline(a1, z));
}



extern void call_idcok (WINDOW * a1, NCURSES_BOOL z);
void call_idcok (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("idcok(%p,%#lx)"), (const void *)a1, (long)z));
	idcok(a1, z);
	returnVoid;
}



extern int call_idlok (WINDOW * a1, NCURSES_BOOL z);
int call_idlok (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("idlok(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(idlok(a1, z));
}



extern void call_immedok (WINDOW * a1, NCURSES_BOOL z);
void call_immedok (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("immedok(%p,%#lx)"), (const void *)a1, (long)z));
	immedok(a1, z);
	returnVoid;
}



extern chtype call_inch (void);
chtype call_inch (void)
{
	T((T_CALLED("inch()")));
	returnChtype(inch());
}



extern int call_inchnstr (chtype * a1, int z);
int call_inchnstr (chtype * a1, int z)
{
	T((T_CALLED("inchnstr(%p,%d)"), (const void *)a1, z));
	returnCode(inchnstr(a1, z));
}



extern int call_inchstr (chtype * z);
int call_inchstr (chtype * z)
{
	T((T_CALLED("inchstr(%p)"), (const void *)z));
	returnCode(inchstr(z));
}



extern WINDOW * call_initscr (void);
WINDOW * call_initscr (void)
{
	T((T_CALLED("initscr()")));
	returnWin(initscr());
}



extern int call_init_color (short a1, short a2, short a3, short z);
int call_init_color (short a1, short a2, short a3, short z)
{
	T((T_CALLED("init_color(%#lx,%#lx,%#lx,%#lx)"), (long)a1, (long)a2, (long)a3, (long)z));
	returnCode(init_color(a1, a2, a3, z));
}



extern int call_init_pair (short a1, short a2, short z);
int call_init_pair (short a1, short a2, short z)
{
	T((T_CALLED("init_pair(%#lx,%#lx,%#lx)"), (long)a1, (long)a2, (long)z));
	returnCode(init_pair(a1, a2, z));
}



extern int call_innstr (char * a1, int z);
int call_innstr (char * a1, int z)
{
	return innstr(a1, z) ;
}



extern int call_insch (chtype z);
int call_insch (chtype z)
{
	T((T_CALLED("insch(%s)"), _tracechtype2(0,z)));
	returnCode(insch(z));
}



extern int call_insdelln (int z);
int call_insdelln (int z)
{
	T((T_CALLED("insdelln(%d)"), z));
	returnCode(insdelln(z));
}



extern int call_insertln (void);
int call_insertln (void)
{
	T((T_CALLED("insertln()")));
	returnCode(insertln());
}



extern int call_insnstr (const char * a1, int z);
int call_insnstr (const char * a1, int z)
{
	T((T_CALLED("insnstr(%s,%d)"), _nc_visbuf2(0,a1), z));
	returnCode(insnstr(a1, z));
}



extern int call_insstr (const char * z);
int call_insstr (const char * z)
{
	T((T_CALLED("insstr(%s)"), _nc_visbuf2(0,z)));
	returnCode(insstr(z));
}



extern int call_instr (char * z);
int call_instr (char * z)
{
	T((T_CALLED("instr(%s)"), _nc_visbuf2(0,z)));
	returnCode(instr(z));
}



extern int call_intrflush (WINDOW * a1, NCURSES_BOOL z);
int call_intrflush (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("intrflush(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(intrflush(a1, z));
}



extern NCURSES_BOOL call_isendwin (void);
NCURSES_BOOL call_isendwin (void)
{
	T((T_CALLED("isendwin()")));
	returnBool(isendwin());
}



extern NCURSES_BOOL call_is_linetouched (WINDOW * a1, int z);
NCURSES_BOOL call_is_linetouched (WINDOW * a1, int z)
{
	T((T_CALLED("is_linetouched(%p,%d)"), (const void *)a1, z));
	returnBool(is_linetouched(a1, z));
}



extern NCURSES_BOOL call_is_wintouched (WINDOW * z);
NCURSES_BOOL call_is_wintouched (WINDOW * z)
{
	T((T_CALLED("is_wintouched(%p)"), (const void *)z));
	returnBool(is_wintouched(z));
}



extern const char * call_keyname (int z);
const char * call_keyname (int z)
{
	T((T_CALLED("keyname(%d)"), z));
	returnCPtr(keyname(z));
}



extern int call_keypad (WINDOW * a1, NCURSES_BOOL z);
int call_keypad (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("keypad(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(keypad(a1, z));
}



extern char call_killchar (void);
char call_killchar (void)
{
	T((T_CALLED("killchar()")));
	returnCode(killchar());
}



extern int call_leaveok (WINDOW * a1, NCURSES_BOOL z);
int call_leaveok (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("leaveok(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(leaveok(a1, z));
}



extern char * call_longname (void);
char * call_longname (void)
{
	T((T_CALLED("longname()")));
	returnPtr(longname());
}



extern int call_meta (WINDOW * a1, NCURSES_BOOL z);
int call_meta (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("meta(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(meta(a1, z));
}



extern int call_move (int a1, int z);
int call_move (int a1, int z)
{
	T((T_CALLED("move(%d,%d)"), a1, z));
	returnCode(move(a1, z));
}



extern int call_mvaddch (int a1, int a2, const chtype z);
int call_mvaddch (int a1, int a2, const chtype z)
{
	T((T_CALLED("mvaddch(%d,%d,%s)"), a1, a2, _tracechtype2(2,z)));
	returnCode(mvaddch(a1, a2, z));
}



extern int call_mvaddchnstr (int a1, int a2, const chtype * a3, int z);
int call_mvaddchnstr (int a1, int a2, const chtype * a3, int z)
{
	T((T_CALLED("mvaddchnstr(%d,%d,%p,%d)"), a1, a2, (const void *)a3, z));
	returnCode(mvaddchnstr(a1, a2, a3, z));
}



extern int call_mvaddchstr (int a1, int a2, const chtype * z);
int call_mvaddchstr (int a1, int a2, const chtype * z)
{
	T((T_CALLED("mvaddchstr(%d,%d,%p)"), a1, a2, (const void *)z));
	returnCode(mvaddchstr(a1, a2, z));
}



extern int call_mvaddnstr (int a1, int a2, const char * a3, int z);
int call_mvaddnstr (int a1, int a2, const char * a3, int z)
{
	T((T_CALLED("mvaddnstr(%d,%d,%s,%d)"), a1, a2, _nc_visbuf2(2,a3), z));
	returnCode(mvaddnstr(a1, a2, a3, z));
}



extern int call_mvaddstr (int a1, int a2, const char * z);
int call_mvaddstr (int a1, int a2, const char * z)
{
	T((T_CALLED("mvaddstr(%d,%d,%s)"), a1, a2, _nc_visbuf2(2,z)));
	returnCode(mvaddstr(a1, a2, z));
}



extern int call_mvchgat (int a1, int a2, int a3, attr_t a4, short a5, const void * z);
int call_mvchgat (int a1, int a2, int a3, attr_t a4, short a5, const void * z)
{
	T((T_CALLED("mvchgat(%d,%d,%d,%s,%#lx,%p)"), a1, a2, a3, _traceattr2(3,a4), (long)a5, (const void *)z));
	returnCode(mvchgat(a1, a2, a3, a4, a5, z));
}



extern int call_mvcur (int a1, int a2, int a3, int z);
int call_mvcur (int a1, int a2, int a3, int z)
{
	T((T_CALLED("mvcur(%d,%d,%d,%d)"), a1, a2, a3, z));
	returnCode(mvcur(a1, a2, a3, z));
}



extern int call_mvdelch (int a1, int z);
int call_mvdelch (int a1, int z)
{
	T((T_CALLED("mvdelch(%d,%d)"), a1, z));
	returnCode(mvdelch(a1, z));
}



extern int call_mvderwin (WINDOW * a1, int a2, int z);
int call_mvderwin (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("mvderwin(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(mvderwin(a1, a2, z));
}



extern int call_mvgetch (int a1, int z);
int call_mvgetch (int a1, int z)
{
	T((T_CALLED("mvgetch(%d,%d)"), a1, z));
	returnCode(mvgetch(a1, z));
}



extern int call_mvgetnstr (int a1, int a2, char * a3, int z);
int call_mvgetnstr (int a1, int a2, char * a3, int z)
{
	T((T_CALLED("mvgetnstr(%d,%d,%p,%d)"), a1, a2, _nc_visbuf2(2,a3), z));
	returnCode(mvgetnstr(a1, a2, a3, z));
}



extern int call_mvgetstr (int a1, int a2, char * z);
int call_mvgetstr (int a1, int a2, char * z)
{
	T((T_CALLED("mvgetstr(%d,%d,%p)"), a1, a2, _nc_visbuf2(2,z)));
	returnCode(mvgetstr(a1, a2, z));
}



extern int call_mvhline (int a1, int a2, chtype a3, int z);
int call_mvhline (int a1, int a2, chtype a3, int z)
{
	T((T_CALLED("mvhline(%d,%d,%s,%d)"), a1, a2, _tracechtype2(2,a3), z));
	returnCode(mvhline(a1, a2, a3, z));
}



extern chtype call_mvinch (int a1, int z);
chtype call_mvinch (int a1, int z)
{
	T((T_CALLED("mvinch(%d,%d)"), a1, z));
	returnChtype(mvinch(a1, z));
}



extern int call_mvinchnstr (int a1, int a2, chtype * a3, int z);
int call_mvinchnstr (int a1, int a2, chtype * a3, int z)
{
	T((T_CALLED("mvinchnstr(%d,%d,%p,%d)"), a1, a2, (const void *)a3, z));
	returnCode(mvinchnstr(a1, a2, a3, z));
}



extern int call_mvinchstr (int a1, int a2, chtype * z);
int call_mvinchstr (int a1, int a2, chtype * z)
{
	T((T_CALLED("mvinchstr(%d,%d,%p)"), a1, a2, (const void *)z));
	returnCode(mvinchstr(a1, a2, z));
}



extern int call_mvinnstr (int a1, int a2, char * a3, int z);
int call_mvinnstr (int a1, int a2, char * a3, int z)
{
	return mvinnstr(a1, a2, a3, z) ;
}



extern int call_mvinsch (int a1, int a2, chtype z);
int call_mvinsch (int a1, int a2, chtype z)
{
	T((T_CALLED("mvinsch(%d,%d,%s)"), a1, a2, _tracechtype2(2,z)));
	returnCode(mvinsch(a1, a2, z));
}



extern int call_mvinsnstr (int a1, int a2, const char * a3, int z);
int call_mvinsnstr (int a1, int a2, const char * a3, int z)
{
	T((T_CALLED("mvinsnstr(%d,%d,%s,%d)"), a1, a2, _nc_visbuf2(2,a3), z));
	returnCode(mvinsnstr(a1, a2, a3, z));
}



extern int call_mvinsstr (int a1, int a2, const char * z);
int call_mvinsstr (int a1, int a2, const char * z)
{
	T((T_CALLED("mvinsstr(%d,%d,%s)"), a1, a2, _nc_visbuf2(2,z)));
	returnCode(mvinsstr(a1, a2, z));
}



extern int call_mvinstr (int a1, int a2, char * z);
int call_mvinstr (int a1, int a2, char * z)
{
	T((T_CALLED("mvinstr(%d,%d,%s)"), a1, a2, _nc_visbuf2(2,z)));
	returnCode(mvinstr(a1, a2, z));
}



extern int call_mvvline (int a1, int a2, chtype a3, int z);
int call_mvvline (int a1, int a2, chtype a3, int z)
{
	T((T_CALLED("mvvline(%d,%d,%s,%d)"), a1, a2, _tracechtype2(2,a3), z));
	returnCode(mvvline(a1, a2, a3, z));
}



extern int call_mvwaddch (WINDOW * a1, int a2, int a3, const chtype z);
int call_mvwaddch (WINDOW * a1, int a2, int a3, const chtype z)
{
	T((T_CALLED("mvwaddch(%p,%d,%d,%s)"), (const void *)a1, a2, a3, _tracechtype2(3,z)));
	returnCode(mvwaddch(a1, a2, a3, z));
}



extern int call_mvwaddchnstr (WINDOW * a1, int a2, int a3, const chtype * a4, int z);
int call_mvwaddchnstr (WINDOW * a1, int a2, int a3, const chtype * a4, int z)
{
	T((T_CALLED("mvwaddchnstr(%p,%d,%d,%p,%d)"), (const void *)a1, a2, a3, (const void *)a4, z));
	returnCode(mvwaddchnstr(a1, a2, a3, a4, z));
}



extern int call_mvwaddchstr (WINDOW * a1, int a2, int a3, const chtype * z);
int call_mvwaddchstr (WINDOW * a1, int a2, int a3, const chtype * z)
{
	T((T_CALLED("mvwaddchstr(%p,%d,%d,%p)"), (const void *)a1, a2, a3, (const void *)z));
	returnCode(mvwaddchstr(a1, a2, a3, z));
}



extern int call_mvwaddnstr (WINDOW * a1, int a2, int a3, const char * a4, int z);
int call_mvwaddnstr (WINDOW * a1, int a2, int a3, const char * a4, int z)
{
	T((T_CALLED("mvwaddnstr(%p,%d,%d,%s,%d)"), (const void *)a1, a2, a3, _nc_visbuf2(3,a4), z));
	returnCode(mvwaddnstr(a1, a2, a3, a4, z));
}



extern int call_mvwaddstr (WINDOW * a1, int a2, int a3, const char * z);
int call_mvwaddstr (WINDOW * a1, int a2, int a3, const char * z)
{
	T((T_CALLED("mvwaddstr(%p,%d,%d,%s)"), (const void *)a1, a2, a3, _nc_visbuf2(3,z)));
	returnCode(mvwaddstr(a1, a2, a3, z));
}



extern int call_mvwchgat (WINDOW * a1, int a2, int a3, int a4, attr_t a5, short a6, const void * z);
int call_mvwchgat (WINDOW * a1, int a2, int a3, int a4, attr_t a5, short a6, const void * z)
{
	T((T_CALLED("mvwchgat(%p,%d,%d,%d,%s,%#lx,%p)"), (const void *)a1, a2, a3, a4, _traceattr2(4,a5), (long)a6, (const void *)z));
	returnCode(mvwchgat(a1, a2, a3, a4, a5, a6, z));
}



extern int call_mvwdelch (WINDOW * a1, int a2, int z);
int call_mvwdelch (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("mvwdelch(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(mvwdelch(a1, a2, z));
}



extern int call_mvwgetch (WINDOW * a1, int a2, int z);
int call_mvwgetch (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("mvwgetch(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(mvwgetch(a1, a2, z));
}



extern int call_mvwgetnstr (WINDOW * a1, int a2, int a3, char * a4, int z);
int call_mvwgetnstr (WINDOW * a1, int a2, int a3, char * a4, int z)
{
	T((T_CALLED("mvwgetnstr(%p,%d,%d,%p,%d)"), (const void *)a1, a2, a3, _nc_visbuf2(3,a4), z));
	returnCode(mvwgetnstr(a1, a2, a3, a4, z));
}



extern int call_mvwgetstr (WINDOW * a1, int a2, int a3, char * z);
int call_mvwgetstr (WINDOW * a1, int a2, int a3, char * z)
{
	T((T_CALLED("mvwgetstr(%p,%d,%d,%p)"), (const void *)a1, a2, a3, _nc_visbuf2(3,z)));
	returnCode(mvwgetstr(a1, a2, a3, z));
}



extern int call_mvwhline (WINDOW * a1, int a2, int a3, chtype a4, int z);
int call_mvwhline (WINDOW * a1, int a2, int a3, chtype a4, int z)
{
	T((T_CALLED("mvwhline(%p,%d,%d,%s,%d)"), (const void *)a1, a2, a3, _tracechtype2(3,a4), z));
	returnCode(mvwhline(a1, a2, a3, a4, z));
}



extern int call_mvwin (WINDOW * a1, int a2, int z);
int call_mvwin (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("mvwin(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(mvwin(a1, a2, z));
}



extern chtype call_mvwinch (WINDOW * a1, int a2, int z);
chtype call_mvwinch (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("mvwinch(%p,%d,%d)"), (const void *)a1, a2, z));
	returnChtype(mvwinch(a1, a2, z));
}



extern int call_mvwinchnstr (WINDOW * a1, int a2, int a3, chtype * a4, int z);
int call_mvwinchnstr (WINDOW * a1, int a2, int a3, chtype * a4, int z)
{
	T((T_CALLED("mvwinchnstr(%p,%d,%d,%p,%d)"), (const void *)a1, a2, a3, (const void *)a4, z));
	returnCode(mvwinchnstr(a1, a2, a3, a4, z));
}



extern int call_mvwinchstr (WINDOW * a1, int a2, int a3, chtype * z);
int call_mvwinchstr (WINDOW * a1, int a2, int a3, chtype * z)
{
	T((T_CALLED("mvwinchstr(%p,%d,%d,%p)"), (const void *)a1, a2, a3, (const void *)z));
	returnCode(mvwinchstr(a1, a2, a3, z));
}



extern int call_mvwinnstr (WINDOW * a1, int a2, int a3, char * a4, int z);
int call_mvwinnstr (WINDOW * a1, int a2, int a3, char * a4, int z)
{
	return mvwinnstr(a1, a2, a3, a4, z) ;
}



extern int call_mvwinsch (WINDOW * a1, int a2, int a3, chtype z);
int call_mvwinsch (WINDOW * a1, int a2, int a3, chtype z)
{
	T((T_CALLED("mvwinsch(%p,%d,%d,%s)"), (const void *)a1, a2, a3, _tracechtype2(3,z)));
	returnCode(mvwinsch(a1, a2, a3, z));
}



extern int call_mvwinsnstr (WINDOW * a1, int a2, int a3, const char * a4, int z);
int call_mvwinsnstr (WINDOW * a1, int a2, int a3, const char * a4, int z)
{
	T((T_CALLED("mvwinsnstr(%p,%d,%d,%s,%d)"), (const void *)a1, a2, a3, _nc_visbuf2(3,a4), z));
	returnCode(mvwinsnstr(a1, a2, a3, a4, z));
}



extern int call_mvwinsstr (WINDOW * a1, int a2, int a3, const char * z);
int call_mvwinsstr (WINDOW * a1, int a2, int a3, const char * z)
{
	T((T_CALLED("mvwinsstr(%p,%d,%d,%s)"), (const void *)a1, a2, a3, _nc_visbuf2(3,z)));
	returnCode(mvwinsstr(a1, a2, a3, z));
}



extern int call_mvwinstr (WINDOW * a1, int a2, int a3, char * z);
int call_mvwinstr (WINDOW * a1, int a2, int a3, char * z)
{
	T((T_CALLED("mvwinstr(%p,%d,%d,%s)"), (const void *)a1, a2, a3, _nc_visbuf2(3,z)));
	returnCode(mvwinstr(a1, a2, a3, z));
}



extern int call_mvwvline (WINDOW * a1, int a2, int a3, chtype a4, int z);
int call_mvwvline (WINDOW * a1, int a2, int a3, chtype a4, int z)
{
	T((T_CALLED("mvwvline(%p,%d,%d,%s,%d)"), (const void *)a1, a2, a3, _tracechtype2(3,a4), z));
	returnCode(mvwvline(a1, a2, a3, a4, z));
}



extern int call_napms (int z);
int call_napms (int z)
{
	T((T_CALLED("napms(%d)"), z));
	returnCode(napms(z));
}



extern WINDOW * call_newpad (int a1, int z);
WINDOW * call_newpad (int a1, int z)
{
	T((T_CALLED("newpad(%d,%d)"), a1, z));
	returnWin(newpad(a1, z));
}



extern struct screen * call_newterm (const char * a1, FILE * a2, FILE * z);
struct screen * call_newterm (const char * a1, FILE * a2, FILE * z)
{
	T((T_CALLED("newterm(%s,%p,%p)"), _nc_visbuf2(0,a1), (const void *)a2, (const void *)z));
	returnSP(newterm(a1, a2, z));
}



extern WINDOW * call_newwin (int a1, int a2, int a3, int z);
WINDOW * call_newwin (int a1, int a2, int a3, int z)
{
	T((T_CALLED("newwin(%d,%d,%d,%d)"), a1, a2, a3, z));
	returnWin(newwin(a1, a2, a3, z));
}



extern int call_nl (void);
int call_nl (void)
{
	T((T_CALLED("nl()")));
	returnCode(nl());
}



extern int call_nocbreak (void);
int call_nocbreak (void)
{
	T((T_CALLED("nocbreak()")));
	returnCode(nocbreak());
}



extern int call_nodelay (WINDOW * a1, NCURSES_BOOL z);
int call_nodelay (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("nodelay(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(nodelay(a1, z));
}



extern int call_noecho (void);
int call_noecho (void)
{
	T((T_CALLED("noecho()")));
	returnCode(noecho());
}



extern int call_nonl (void);
int call_nonl (void)
{
	T((T_CALLED("nonl()")));
	returnCode(nonl());
}



extern void call_noqiflush (void);
void call_noqiflush (void)
{
	T((T_CALLED("noqiflush()")));
	noqiflush();
	returnVoid;
}



extern int call_noraw (void);
int call_noraw (void)
{
	T((T_CALLED("noraw()")));
	returnCode(noraw());
}



extern int call_notimeout (WINDOW * a1, NCURSES_BOOL z);
int call_notimeout (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("notimeout(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(notimeout(a1, z));
}



extern int call_overlay (const WINDOW * a1, WINDOW * z);
int call_overlay (const WINDOW * a1, WINDOW * z)
{
	T((T_CALLED("overlay(%p,%p)"), (const void *)a1, (const void *)z));
	returnCode(overlay(a1, z));
}



extern int call_overwrite (const WINDOW * a1, WINDOW * z);
int call_overwrite (const WINDOW * a1, WINDOW * z)
{
	T((T_CALLED("overwrite(%p,%p)"), (const void *)a1, (const void *)z));
	returnCode(overwrite(a1, z));
}



extern int call_pair_content (short a1, short * a2, short * z);
int call_pair_content (short a1, short * a2, short * z)
{
	T((T_CALLED("pair_content(%#lx,%p,%p)"), (long)a1, (const void *)a2, (const void *)z));
	returnCode(pair_content(a1, a2, z));
}



extern int call_PAIR_NUMBER (int z);
int call_PAIR_NUMBER (int z)
{
	T((T_CALLED("PAIR_NUMBER(%d)"), z));
	returnCode(PAIR_NUMBER(z));
}



extern int call_pechochar (WINDOW * a1, const chtype z);
int call_pechochar (WINDOW * a1, const chtype z)
{
	T((T_CALLED("pechochar(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(pechochar(a1, z));
}



extern int call_pnoutrefresh (WINDOW * a1, int a2, int a3, int a4, int a5, int a6, int z);
int call_pnoutrefresh (WINDOW * a1, int a2, int a3, int a4, int a5, int a6, int z)
{
	T((T_CALLED("pnoutrefresh(%p,%d,%d,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, a5, a6, z));
	returnCode(pnoutrefresh(a1, a2, a3, a4, a5, a6, z));
}



extern int call_prefresh (WINDOW * a1, int a2, int a3, int a4, int a5, int a6, int z);
int call_prefresh (WINDOW * a1, int a2, int a3, int a4, int a5, int a6, int z)
{
	T((T_CALLED("prefresh(%p,%d,%d,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, a5, a6, z));
	returnCode(prefresh(a1, a2, a3, a4, a5, a6, z));
}



extern int call_putwin (WINDOW * a1, FILE * z);
int call_putwin (WINDOW * a1, FILE * z)
{
	T((T_CALLED("putwin(%p,%p)"), (const void *)a1, (const void *)z));
	returnCode(putwin(a1, z));
}



extern void call_qiflush (void);
void call_qiflush (void)
{
	T((T_CALLED("qiflush()")));
	qiflush();
	returnVoid;
}



extern int call_raw (void);
int call_raw (void)
{
	T((T_CALLED("raw()")));
	returnCode(raw());
}



extern int call_redrawwin (WINDOW * z);
int call_redrawwin (WINDOW * z)
{
	T((T_CALLED("redrawwin(%p)"), (const void *)z));
	returnCode(redrawwin(z));
}



extern int call_refresh (void);
int call_refresh (void)
{
	T((T_CALLED("refresh()")));
	returnCode(refresh());
}



extern int call_resetty (void);
int call_resetty (void)
{
	T((T_CALLED("resetty()")));
	returnCode(resetty());
}



extern int call_reset_prog_mode (void);
int call_reset_prog_mode (void)
{
	T((T_CALLED("reset_prog_mode()")));
	returnCode(reset_prog_mode());
}



extern int call_reset_shell_mode (void);
int call_reset_shell_mode (void)
{
	T((T_CALLED("reset_shell_mode()")));
	returnCode(reset_shell_mode());
}



extern int call_ripoffline (int a1, int(* z)(WINDOW * a2, int));
int call_ripoffline (int a1, int(* z)(WINDOW * a2, int))
{
	return ripoffline(a1, z) ;
}



extern int call_savetty (void);
int call_savetty (void)
{
	T((T_CALLED("savetty()")));
	returnCode(savetty());
}



extern int call_scr_dump (const char * z);
int call_scr_dump (const char * z)
{
	T((T_CALLED("scr_dump(%s)"), _nc_visbuf2(0,z)));
	returnCode(scr_dump(z));
}



extern int call_scr_init (const char * z);
int call_scr_init (const char * z)
{
	T((T_CALLED("scr_init(%s)"), _nc_visbuf2(0,z)));
	returnCode(scr_init(z));
}



extern int call_scrl (int z);
int call_scrl (int z)
{
	T((T_CALLED("scrl(%d)"), z));
	returnCode(scrl(z));
}



extern int call_scroll (WINDOW * z);
int call_scroll (WINDOW * z)
{
	T((T_CALLED("scroll(%p)"), (const void *)z));
	returnCode(scroll(z));
}



extern int call_scrollok (WINDOW * a1, NCURSES_BOOL z);
int call_scrollok (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("scrollok(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(scrollok(a1, z));
}



extern int call_scr_restore (const char * z);
int call_scr_restore (const char * z)
{
	T((T_CALLED("scr_restore(%s)"), _nc_visbuf2(0,z)));
	returnCode(scr_restore(z));
}



extern int call_scr_set (const char * z);
int call_scr_set (const char * z)
{
	T((T_CALLED("scr_set(%s)"), _nc_visbuf2(0,z)));
	returnCode(scr_set(z));
}



extern int call_setscrreg (int a1, int z);
int call_setscrreg (int a1, int z)
{
	T((T_CALLED("setscrreg(%d,%d)"), a1, z));
	returnCode(setscrreg(a1, z));
}



extern struct screen * call_set_term (struct screen * z);
struct screen * call_set_term (struct screen * z)
{
	T((T_CALLED("set_term(%p)"), (const void *)z));
	returnSP(set_term(z));
}



extern int call_slk_attroff (const chtype z);
int call_slk_attroff (const chtype z)
{
	T((T_CALLED("slk_attroff(%s)"), _tracechtype2(0,z)));
	returnCode(slk_attroff(z));
}


#if USE_WIDEC_SUPPORT

extern int call_slk_attr_off (const attr_t a1, void * z);
int call_slk_attr_off (const attr_t a1, void * z)
{
	T((T_CALLED("slk_attr_off(%s,%p)"), _traceattr2(0,a1), (const void *)z));
	returnCode(slk_attr_off(a1, z));
}
#endif



extern int call_slk_attron (const chtype z);
int call_slk_attron (const chtype z)
{
	T((T_CALLED("slk_attron(%s)"), _tracechtype2(0,z)));
	returnCode(slk_attron(z));
}


#if USE_WIDEC_SUPPORT

extern int call_slk_attr_on (attr_t a1, void * z);
int call_slk_attr_on (attr_t a1, void * z)
{
	T((T_CALLED("slk_attr_on(%s,%p)"), _traceattr2(0,a1), (const void *)z));
	returnCode(slk_attr_on(a1, z));
}
#endif



extern int call_slk_attrset (const chtype z);
int call_slk_attrset (const chtype z)
{
	T((T_CALLED("slk_attrset(%s)"), _tracechtype2(0,z)));
	returnCode(slk_attrset(z));
}



extern attr_t call_slk_attr (void);
attr_t call_slk_attr (void)
{
	T((T_CALLED("slk_attr()")));
	returnIntAttr((attr_t)slk_attr());
}



extern int call_slk_attr_set (const attr_t a1, short a2, void * z);
int call_slk_attr_set (const attr_t a1, short a2, void * z)
{
	T((T_CALLED("slk_attr_set(%s,%#lx,%p)"), _traceattr2(0,a1), (long)a2, (const void *)z));
	returnCode(slk_attr_set(a1, a2, z));
}



extern int call_slk_clear (void);
int call_slk_clear (void)
{
	T((T_CALLED("slk_clear()")));
	returnCode(slk_clear());
}



extern int call_slk_color (short z);
int call_slk_color (short z)
{
	T((T_CALLED("slk_color(%#lx)"), (long)z));
	returnCode(slk_color(z));
}



extern int call_slk_init (int z);
int call_slk_init (int z)
{
	T((T_CALLED("slk_init(%d)"), z));
	returnCode(slk_init(z));
}



extern char * call_slk_label (int z);
char * call_slk_label (int z)
{
	T((T_CALLED("slk_label(%d)"), z));
	returnPtr(slk_label(z));
}



extern int call_slk_noutrefresh (void);
int call_slk_noutrefresh (void)
{
	T((T_CALLED("slk_noutrefresh()")));
	returnCode(slk_noutrefresh());
}



extern int call_slk_refresh (void);
int call_slk_refresh (void)
{
	T((T_CALLED("slk_refresh()")));
	returnCode(slk_refresh());
}



extern int call_slk_restore (void);
int call_slk_restore (void)
{
	T((T_CALLED("slk_restore()")));
	returnCode(slk_restore());
}



extern int call_slk_set (int a1, const char * a2, int z);
int call_slk_set (int a1, const char * a2, int z)
{
	T((T_CALLED("slk_set(%d,%s,%d)"), a1, _nc_visbuf2(1,a2), z));
	returnCode(slk_set(a1, a2, z));
}



extern int call_slk_touch (void);
int call_slk_touch (void)
{
	T((T_CALLED("slk_touch()")));
	returnCode(slk_touch());
}



extern int call_standout (void);
int call_standout (void)
{
	T((T_CALLED("standout()")));
	returnIntAttr((attr_t)standout());
}



extern int call_standend (void);
int call_standend (void)
{
	T((T_CALLED("standend()")));
	returnIntAttr((attr_t)standend());
}



extern int call_start_color (void);
int call_start_color (void)
{
	T((T_CALLED("start_color()")));
	returnCode(start_color());
}



extern WINDOW * call_subpad (WINDOW * a1, int a2, int a3, int a4, int z);
WINDOW * call_subpad (WINDOW * a1, int a2, int a3, int a4, int z)
{
	T((T_CALLED("subpad(%p,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, z));
	returnWin(subpad(a1, a2, a3, a4, z));
}



extern WINDOW * call_subwin (WINDOW * a1, int a2, int a3, int a4, int z);
WINDOW * call_subwin (WINDOW * a1, int a2, int a3, int a4, int z)
{
	T((T_CALLED("subwin(%p,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, z));
	returnWin(subwin(a1, a2, a3, a4, z));
}



extern int call_syncok (WINDOW * a1, NCURSES_BOOL z);
int call_syncok (WINDOW * a1, NCURSES_BOOL z)
{
	T((T_CALLED("syncok(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(syncok(a1, z));
}



extern chtype call_termattrs (void);
chtype call_termattrs (void)
{
	T((T_CALLED("termattrs()")));
	returnChtype(termattrs());
}



extern char * call_termname (void);
char * call_termname (void)
{
	T((T_CALLED("termname()")));
	returnPtr(termname());
}



extern void call_timeout (int z);
void call_timeout (int z)
{
	T((T_CALLED("timeout(%d)"), z));
	timeout(z);
	returnVoid;
}



extern int call_touchline (WINDOW * a1, int a2, int z);
int call_touchline (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("touchline(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(touchline(a1, a2, z));
}



extern int call_touchwin (WINDOW * z);
int call_touchwin (WINDOW * z)
{
	T((T_CALLED("touchwin(%p)"), (const void *)z));
	returnCode(touchwin(z));
}



extern int call_typeahead (int z);
int call_typeahead (int z)
{
	T((T_CALLED("typeahead(%d)"), z));
	returnCode(typeahead(z));
}



extern int call_ungetch (int z);
int call_ungetch (int z)
{
	T((T_CALLED("ungetch(%d)"), z));
	returnCode(ungetch(z));
}



extern int call_untouchwin (WINDOW * z);
int call_untouchwin (WINDOW * z)
{
	T((T_CALLED("untouchwin(%p)"), (const void *)z));
	returnCode(untouchwin(z));
}



extern void call_use_env (NCURSES_BOOL z);
void call_use_env (NCURSES_BOOL z)
{
	T((T_CALLED("use_env(%#lx)"), (long)z));
	use_env(z);
	returnVoid;
}



extern void call_use_tioctl (NCURSES_BOOL z);
void call_use_tioctl (NCURSES_BOOL z)
{
	T((T_CALLED("use_tioctl(%#lx)"), (long)z));
	use_tioctl(z);
	returnVoid;
}



extern int call_vidattr (chtype z);
int call_vidattr (chtype z)
{
	T((T_CALLED("vidattr(%s)"), _tracechtype2(0,z)));
	returnCode(vidattr(z));
}



extern int call_vidputs (chtype a1, NCURSES_OUTC z);
int call_vidputs (chtype a1, NCURSES_OUTC z)
{
	T((T_CALLED("vidputs(%s,%#lx)"), _tracechtype2(0,a1), (long)z));
	returnCode(vidputs(a1, z));
}



extern int call_vline (chtype a1, int z);
int call_vline (chtype a1, int z)
{
	T((T_CALLED("vline(%s,%d)"), _tracechtype2(0,a1), z));
	returnCode(vline(a1, z));
}



extern int call_waddch (WINDOW * a1, const chtype z);
int call_waddch (WINDOW * a1, const chtype z)
{
	T((T_CALLED("waddch(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(waddch(a1, z));
}



extern int call_waddchnstr (WINDOW * a1, const chtype * a2, int z);
int call_waddchnstr (WINDOW * a1, const chtype * a2, int z)
{
	T((T_CALLED("waddchnstr(%p,%p,%d)"), (const void *)a1, (const void *)a2, z));
	returnCode(waddchnstr(a1, a2, z));
}



extern int call_waddchstr (WINDOW * a1, const chtype * z);
int call_waddchstr (WINDOW * a1, const chtype * z)
{
	T((T_CALLED("waddchstr(%p,%p)"), (const void *)a1, (const void *)z));
	returnCode(waddchstr(a1, z));
}



extern int call_waddnstr (WINDOW * a1, const char * a2, int z);
int call_waddnstr (WINDOW * a1, const char * a2, int z)
{
	T((T_CALLED("waddnstr(%p,%s,%d)"), (const void *)a1, _nc_visbuf2(1,a2), z));
	returnCode(waddnstr(a1, a2, z));
}



extern int call_waddstr (WINDOW * a1, const char * z);
int call_waddstr (WINDOW * a1, const char * z)
{
	T((T_CALLED("waddstr(%p,%s)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(waddstr(a1, z));
}



extern int call_wattron (WINDOW * a1, int z);
int call_wattron (WINDOW * a1, int z)
{
	T((T_CALLED("wattron(%p,%d)"), (const void *)a1, z));
	returnCode(wattron(a1, z));
}



extern int call_wattroff (WINDOW * a1, int z);
int call_wattroff (WINDOW * a1, int z)
{
	T((T_CALLED("wattroff(%p,%d)"), (const void *)a1, z));
	returnCode(wattroff(a1, z));
}



extern int call_wattrset (WINDOW * a1, int z);
int call_wattrset (WINDOW * a1, int z)
{
	T((T_CALLED("wattrset(%p,%d)"), (const void *)a1, z));
	returnIntAttr((attr_t)wattrset(a1, z));
}



extern int call_wattr_get (WINDOW * a1, attr_t * a2, short * a3, void * z);
int call_wattr_get (WINDOW * a1, attr_t * a2, short * a3, void * z)
{
	T((T_CALLED("wattr_get(%p,%p,%p,%p)"), (const void *)a1, (const void *)a2, (const void *)a3, (const void *)z));
	returnCode(wattr_get(a1, a2, a3, z));
}



extern int call_wattr_on (WINDOW * a1, attr_t a2, void * z);
int call_wattr_on (WINDOW * a1, attr_t a2, void * z)
{
	T((T_CALLED("wattr_on(%p,%s,%p)"), (const void *)a1, _traceattr2(1,a2), (const void *)z));
	returnCode(wattr_on(a1, a2, z));
}



extern int call_wattr_off (WINDOW * a1, attr_t a2, void * z);
int call_wattr_off (WINDOW * a1, attr_t a2, void * z)
{
	T((T_CALLED("wattr_off(%p,%s,%p)"), (const void *)a1, _traceattr2(1,a2), (const void *)z));
	returnCode(wattr_off(a1, a2, z));
}



extern int call_wattr_set (WINDOW * a1, attr_t a2, short a3, void * z);
int call_wattr_set (WINDOW * a1, attr_t a2, short a3, void * z)
{
	T((T_CALLED("wattr_set(%p,%s,%#lx,%p)"), (const void *)a1, _traceattr2(1,a2), (long)a3, (const void *)z));
	returnCode(wattr_set(a1, a2, a3, z));
}



extern int call_wbkgd (WINDOW * a1, chtype z);
int call_wbkgd (WINDOW * a1, chtype z)
{
	T((T_CALLED("wbkgd(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(wbkgd(a1, z));
}



extern void call_wbkgdset (WINDOW * a1, chtype z);
void call_wbkgdset (WINDOW * a1, chtype z)
{
	T((T_CALLED("wbkgdset(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	wbkgdset(a1, z);
	returnVoid;
}



extern int call_wborder (WINDOW * a1, chtype a2, chtype a3, chtype a4, chtype a5, chtype a6, chtype a7, chtype a8, chtype z);
int call_wborder (WINDOW * a1, chtype a2, chtype a3, chtype a4, chtype a5, chtype a6, chtype a7, chtype a8, chtype z)
{
	T((T_CALLED("wborder(%p,%s,%s,%s,%s,%s,%s,%s,%s)"), (const void *)a1, _tracechtype2(1,a2), _tracechtype2(2,a3), _tracechtype2(3,a4), _tracechtype2(4,a5), _tracechtype2(5,a6), _tracechtype2(6,a7), _tracechtype2(7,a8), _tracechtype2(8,z)));
	returnCode(wborder(a1, a2, a3, a4, a5, a6, a7, a8, z));
}



extern int call_wchgat (WINDOW * a1, int a2, attr_t a3, short a4, const void * z);
int call_wchgat (WINDOW * a1, int a2, attr_t a3, short a4, const void * z)
{
	T((T_CALLED("wchgat(%p,%d,%s,%#lx,%p)"), (const void *)a1, a2, _traceattr2(2,a3), (long)a4, (const void *)z));
	returnCode(wchgat(a1, a2, a3, a4, z));
}



extern int call_wclear (WINDOW * z);
int call_wclear (WINDOW * z)
{
	T((T_CALLED("wclear(%p)"), (const void *)z));
	returnCode(wclear(z));
}



extern int call_wclrtobot (WINDOW * z);
int call_wclrtobot (WINDOW * z)
{
	T((T_CALLED("wclrtobot(%p)"), (const void *)z));
	returnCode(wclrtobot(z));
}



extern int call_wclrtoeol (WINDOW * z);
int call_wclrtoeol (WINDOW * z)
{
	T((T_CALLED("wclrtoeol(%p)"), (const void *)z));
	returnCode(wclrtoeol(z));
}



extern int call_wcolor_set (WINDOW * a1, short a2, void * z);
int call_wcolor_set (WINDOW * a1, short a2, void * z)
{
	T((T_CALLED("wcolor_set(%p,%#lx,%p)"), (const void *)a1, (long)a2, (const void *)z));
	returnCode(wcolor_set(a1, a2, z));
}



extern void call_wcursyncup (WINDOW * z);
void call_wcursyncup (WINDOW * z)
{
	T((T_CALLED("wcursyncup(%p)"), (const void *)z));
	wcursyncup(z);
	returnVoid;
}



extern int call_wdelch (WINDOW * z);
int call_wdelch (WINDOW * z)
{
	T((T_CALLED("wdelch(%p)"), (const void *)z));
	returnCode(wdelch(z));
}



extern int call_wdeleteln (WINDOW * z);
int call_wdeleteln (WINDOW * z)
{
	T((T_CALLED("wdeleteln(%p)"), (const void *)z));
	returnCode(wdeleteln(z));
}



extern int call_wechochar (WINDOW * a1, const chtype z);
int call_wechochar (WINDOW * a1, const chtype z)
{
	T((T_CALLED("wechochar(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(wechochar(a1, z));
}



extern int call_werase (WINDOW * z);
int call_werase (WINDOW * z)
{
	T((T_CALLED("werase(%p)"), (const void *)z));
	returnCode(werase(z));
}



extern int call_wgetch (WINDOW * z);
int call_wgetch (WINDOW * z)
{
	T((T_CALLED("wgetch(%p)"), (const void *)z));
	returnCode(wgetch(z));
}



extern int call_wgetnstr (WINDOW * a1, char * a2, int z);
int call_wgetnstr (WINDOW * a1, char * a2, int z)
{
	T((T_CALLED("wgetnstr(%p,%p,%d)"), (const void *)a1, _nc_visbuf2(1,a2), z));
	returnCode(wgetnstr(a1, a2, z));
}



extern int call_wgetstr (WINDOW * a1, char * z);
int call_wgetstr (WINDOW * a1, char * z)
{
	T((T_CALLED("wgetstr(%p,%p)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(wgetstr(a1, z));
}



extern int call_whline (WINDOW * a1, chtype a2, int z);
int call_whline (WINDOW * a1, chtype a2, int z)
{
	T((T_CALLED("whline(%p,%s,%d)"), (const void *)a1, _tracechtype2(1,a2), z));
	returnCode(whline(a1, a2, z));
}



extern chtype call_winch (WINDOW * z);
chtype call_winch (WINDOW * z)
{
	T((T_CALLED("winch(%p)"), (const void *)z));
	returnChtype(winch(z));
}



extern int call_winchnstr (WINDOW * a1, chtype * a2, int z);
int call_winchnstr (WINDOW * a1, chtype * a2, int z)
{
	T((T_CALLED("winchnstr(%p,%p,%d)"), (const void *)a1, (const void *)a2, z));
	returnCode(winchnstr(a1, a2, z));
}



extern int call_winchstr (WINDOW * a1, chtype * z);
int call_winchstr (WINDOW * a1, chtype * z)
{
	T((T_CALLED("winchstr(%p,%p)"), (const void *)a1, (const void *)z));
	returnCode(winchstr(a1, z));
}



extern int call_winnstr (WINDOW * a1, char * a2, int z);
int call_winnstr (WINDOW * a1, char * a2, int z)
{
	return winnstr(a1, a2, z) ;
}



extern int call_winsch (WINDOW * a1, chtype z);
int call_winsch (WINDOW * a1, chtype z)
{
	T((T_CALLED("winsch(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(winsch(a1, z));
}



extern int call_winsdelln (WINDOW * a1, int z);
int call_winsdelln (WINDOW * a1, int z)
{
	T((T_CALLED("winsdelln(%p,%d)"), (const void *)a1, z));
	returnCode(winsdelln(a1, z));
}



extern int call_winsertln (WINDOW * z);
int call_winsertln (WINDOW * z)
{
	T((T_CALLED("winsertln(%p)"), (const void *)z));
	returnCode(winsertln(z));
}



extern int call_winsnstr (WINDOW * a1, const char * a2, int z);
int call_winsnstr (WINDOW * a1, const char * a2, int z)
{
	T((T_CALLED("winsnstr(%p,%s,%d)"), (const void *)a1, _nc_visbuf2(1,a2), z));
	returnCode(winsnstr(a1, a2, z));
}



extern int call_winsstr (WINDOW * a1, const char * z);
int call_winsstr (WINDOW * a1, const char * z)
{
	T((T_CALLED("winsstr(%p,%s)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(winsstr(a1, z));
}



extern int call_winstr (WINDOW * a1, char * z);
int call_winstr (WINDOW * a1, char * z)
{
	T((T_CALLED("winstr(%p,%s)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(winstr(a1, z));
}



extern int call_wmove (WINDOW * a1, int a2, int z);
int call_wmove (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("wmove(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(wmove(a1, a2, z));
}



extern int call_wnoutrefresh (WINDOW * z);
int call_wnoutrefresh (WINDOW * z)
{
	T((T_CALLED("wnoutrefresh(%p)"), (const void *)z));
	returnCode(wnoutrefresh(z));
}



extern int call_wredrawln (WINDOW * a1, int a2, int z);
int call_wredrawln (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("wredrawln(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(wredrawln(a1, a2, z));
}



extern int call_wrefresh (WINDOW * z);
int call_wrefresh (WINDOW * z)
{
	T((T_CALLED("wrefresh(%p)"), (const void *)z));
	returnCode(wrefresh(z));
}



extern int call_wscrl (WINDOW * a1, int z);
int call_wscrl (WINDOW * a1, int z)
{
	T((T_CALLED("wscrl(%p,%d)"), (const void *)a1, z));
	returnCode(wscrl(a1, z));
}



extern int call_wsetscrreg (WINDOW * a1, int a2, int z);
int call_wsetscrreg (WINDOW * a1, int a2, int z)
{
	T((T_CALLED("wsetscrreg(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(wsetscrreg(a1, a2, z));
}



extern int call_wstandout (WINDOW * z);
int call_wstandout (WINDOW * z)
{
	T((T_CALLED("wstandout(%p)"), (const void *)z));
	returnIntAttr((attr_t)wstandout(z));
}



extern int call_wstandend (WINDOW * z);
int call_wstandend (WINDOW * z)
{
	T((T_CALLED("wstandend(%p)"), (const void *)z));
	returnIntAttr((attr_t)wstandend(z));
}



extern void call_wsyncdown (WINDOW * z);
void call_wsyncdown (WINDOW * z)
{
	T((T_CALLED("wsyncdown(%p)"), (const void *)z));
	wsyncdown(z);
	returnVoid;
}



extern void call_wsyncup (WINDOW * z);
void call_wsyncup (WINDOW * z)
{
	T((T_CALLED("wsyncup(%p)"), (const void *)z));
	wsyncup(z);
	returnVoid;
}



extern void call_wtimeout (WINDOW * a1, int z);
void call_wtimeout (WINDOW * a1, int z)
{
	T((T_CALLED("wtimeout(%p,%d)"), (const void *)a1, z));
	wtimeout(a1, z);
	returnVoid;
}



extern int call_wtouchln (WINDOW * a1, int a2, int a3, int z);
int call_wtouchln (WINDOW * a1, int a2, int a3, int z)
{
	T((T_CALLED("wtouchln(%p,%d,%d,%d)"), (const void *)a1, a2, a3, z));
	returnCode(wtouchln(a1, a2, a3, z));
}



extern int call_wvline (WINDOW * a1, chtype a2, int z);
int call_wvline (WINDOW * a1, chtype a2, int z)
{
	T((T_CALLED("wvline(%p,%s,%d)"), (const void *)a1, _tracechtype2(1,a2), z));
	returnCode(wvline(a1, a2, z));
}



extern int call_tigetflag (const char * z);
int call_tigetflag (const char * z)
{
	T((T_CALLED("tigetflag(%s)"), _nc_visbuf2(0,z)));
	returnCode(tigetflag(z));
}



extern int call_tigetnum (const char * z);
int call_tigetnum (const char * z)
{
	T((T_CALLED("tigetnum(%s)"), _nc_visbuf2(0,z)));
	returnCode(tigetnum(z));
}



extern char * call_tigetstr (const char * z);
char * call_tigetstr (const char * z)
{
	T((T_CALLED("tigetstr(%p)"), _nc_visbuf2(0,z)));
	returnPtr(tigetstr(z));
}



extern int call_putp (const char * z);
int call_putp (const char * z)
{
	T((T_CALLED("putp(%s)"), _nc_visbuf2(0,z)));
	returnCode(putp(z));
}



extern int call_getattrs (const WINDOW * z);
int call_getattrs (const WINDOW * z)
{
	T((T_CALLED("getattrs(%p)"), (const void *)z));
	returnCode(getattrs(z));
}



extern int call_getcurx (const WINDOW * z);
int call_getcurx (const WINDOW * z)
{
	T((T_CALLED("getcurx(%p)"), (const void *)z));
	returnCode(getcurx(z));
}



extern int call_getcury (const WINDOW * z);
int call_getcury (const WINDOW * z)
{
	T((T_CALLED("getcury(%p)"), (const void *)z));
	returnCode(getcury(z));
}



extern int call_getbegx (const WINDOW * z);
int call_getbegx (const WINDOW * z)
{
	T((T_CALLED("getbegx(%p)"), (const void *)z));
	returnCode(getbegx(z));
}



extern int call_getbegy (const WINDOW * z);
int call_getbegy (const WINDOW * z)
{
	T((T_CALLED("getbegy(%p)"), (const void *)z));
	returnCode(getbegy(z));
}



extern int call_getmaxx (const WINDOW * z);
int call_getmaxx (const WINDOW * z)
{
	T((T_CALLED("getmaxx(%p)"), (const void *)z));
	returnCode(getmaxx(z));
}



extern int call_getmaxy (const WINDOW * z);
int call_getmaxy (const WINDOW * z)
{
	T((T_CALLED("getmaxy(%p)"), (const void *)z));
	returnCode(getmaxy(z));
}



extern int call_getparx (const WINDOW * z);
int call_getparx (const WINDOW * z)
{
	T((T_CALLED("getparx(%p)"), (const void *)z));
	returnCode(getparx(z));
}



extern int call_getpary (const WINDOW * z);
int call_getpary (const WINDOW * z)
{
	T((T_CALLED("getpary(%p)"), (const void *)z));
	returnCode(getpary(z));
}



extern WINDOW * call_wgetparent (const WINDOW * z);
WINDOW * call_wgetparent (const WINDOW * z)
{
	T((T_CALLED("wgetparent(%p)"), (const void *)z));
	returnWin(wgetparent(z));
}



extern NCURSES_BOOL call_is_cleared (const WINDOW * z);
NCURSES_BOOL call_is_cleared (const WINDOW * z)
{
	T((T_CALLED("is_cleared(%p)"), (const void *)z));
	returnBool(is_cleared(z));
}



extern NCURSES_BOOL call_is_idcok (const WINDOW * z);
NCURSES_BOOL call_is_idcok (const WINDOW * z)
{
	T((T_CALLED("is_idcok(%p)"), (const void *)z));
	returnBool(is_idcok(z));
}



extern NCURSES_BOOL call_is_idlok (const WINDOW * z);
NCURSES_BOOL call_is_idlok (const WINDOW * z)
{
	T((T_CALLED("is_idlok(%p)"), (const void *)z));
	returnBool(is_idlok(z));
}



extern NCURSES_BOOL call_is_immedok (const WINDOW * z);
NCURSES_BOOL call_is_immedok (const WINDOW * z)
{
	T((T_CALLED("is_immedok(%p)"), (const void *)z));
	returnBool(is_immedok(z));
}



extern NCURSES_BOOL call_is_keypad (const WINDOW * z);
NCURSES_BOOL call_is_keypad (const WINDOW * z)
{
	T((T_CALLED("is_keypad(%p)"), (const void *)z));
	returnBool(is_keypad(z));
}



extern NCURSES_BOOL call_is_leaveok (const WINDOW * z);
NCURSES_BOOL call_is_leaveok (const WINDOW * z)
{
	T((T_CALLED("is_leaveok(%p)"), (const void *)z));
	returnBool(is_leaveok(z));
}



extern NCURSES_BOOL call_is_nodelay (const WINDOW * z);
NCURSES_BOOL call_is_nodelay (const WINDOW * z)
{
	T((T_CALLED("is_nodelay(%p)"), (const void *)z));
	returnBool(is_nodelay(z));
}



extern NCURSES_BOOL call_is_notimeout (const WINDOW * z);
NCURSES_BOOL call_is_notimeout (const WINDOW * z)
{
	T((T_CALLED("is_notimeout(%p)"), (const void *)z));
	returnBool(is_notimeout(z));
}



extern NCURSES_BOOL call_is_pad (const WINDOW * z);
NCURSES_BOOL call_is_pad (const WINDOW * z)
{
	T((T_CALLED("is_pad(%p)"), (const void *)z));
	returnBool(is_pad(z));
}



extern NCURSES_BOOL call_is_scrollok (const WINDOW * z);
NCURSES_BOOL call_is_scrollok (const WINDOW * z)
{
	T((T_CALLED("is_scrollok(%p)"), (const void *)z));
	returnBool(is_scrollok(z));
}



extern NCURSES_BOOL call_is_subwin (const WINDOW * z);
NCURSES_BOOL call_is_subwin (const WINDOW * z)
{
	T((T_CALLED("is_subwin(%p)"), (const void *)z));
	returnBool(is_subwin(z));
}



extern NCURSES_BOOL call_is_syncok (const WINDOW * z);
NCURSES_BOOL call_is_syncok (const WINDOW * z)
{
	T((T_CALLED("is_syncok(%p)"), (const void *)z));
	returnBool(is_syncok(z));
}



extern int call_wgetdelay (const WINDOW * z);
int call_wgetdelay (const WINDOW * z)
{
	T((T_CALLED("wgetdelay(%p)"), (const void *)z));
	returnCode(wgetdelay(z));
}



extern int call_wgetscrreg (const WINDOW * a1, int * a2, int * z);
int call_wgetscrreg (const WINDOW * a1, int * a2, int * z)
{
	T((T_CALLED("wgetscrreg(%p,%p,%p)"), (const void *)a1, (const void *)a2, (const void *)z));
	returnCode(wgetscrreg(a1, a2, z));
}


#if USE_SP_FUNC_SUPPORT

extern struct screen * call_new_prescr (void);
struct screen * call_new_prescr (void)
{
	T((T_CALLED("new_prescr()")));
	returnSP(new_prescr());
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___baudrate (struct screen * z);
int call_NCURSES_SP_NAME___baudrate (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(baudrate)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(baudrate)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___beep (struct screen * z);
int call_NCURSES_SP_NAME___beep (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(beep)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(beep)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern NCURSES_BOOL call_NCURSES_SP_NAME___can_change_color (struct screen * z);
NCURSES_BOOL call_NCURSES_SP_NAME___can_change_color (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(can_change_color)(%p)"), (const void *)z));
	returnBool(NCURSES_SP_NAME(can_change_color)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___cbreak (struct screen * z);
int call_NCURSES_SP_NAME___cbreak (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(cbreak)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(cbreak)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___curs_set (struct screen * a1, int z);
int call_NCURSES_SP_NAME___curs_set (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(curs_set)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(curs_set)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___color_content (struct screen * a1, short a2, short * a3, short * a4, short * z);
int call_NCURSES_SP_NAME___color_content (struct screen * a1, short a2, short * a3, short * a4, short * z)
{
	T((T_CALLED("NCURSES_SP_NAME(color_content)(%p,%#lx,%p,%p,%p)"), (const void *)a1, (long)a2, (const void *)a3, (const void *)a4, (const void *)z));
	returnCode(NCURSES_SP_NAME(color_content)(a1, a2, a3, a4, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___def_prog_mode (struct screen * z);
int call_NCURSES_SP_NAME___def_prog_mode (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(def_prog_mode)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(def_prog_mode)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___def_shell_mode (struct screen * z);
int call_NCURSES_SP_NAME___def_shell_mode (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(def_shell_mode)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(def_shell_mode)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___delay_output (struct screen * a1, int z);
int call_NCURSES_SP_NAME___delay_output (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(delay_output)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(delay_output)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___doupdate (struct screen * z);
int call_NCURSES_SP_NAME___doupdate (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(doupdate)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(doupdate)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___echo (struct screen * z);
int call_NCURSES_SP_NAME___echo (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(echo)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(echo)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___endwin (struct screen * z);
int call_NCURSES_SP_NAME___endwin (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(endwin)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(endwin)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern char call_NCURSES_SP_NAME___erasechar (struct screen * z);
char call_NCURSES_SP_NAME___erasechar (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(erasechar)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(erasechar)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern void call_NCURSES_SP_NAME___filter (struct screen * z);
void call_NCURSES_SP_NAME___filter (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(filter)(%p)"), (const void *)z));
	NCURSES_SP_NAME(filter)(z);
	returnVoid;
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___flash (struct screen * z);
int call_NCURSES_SP_NAME___flash (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(flash)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(flash)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___flushinp (struct screen * z);
int call_NCURSES_SP_NAME___flushinp (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(flushinp)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(flushinp)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern WINDOW * call_NCURSES_SP_NAME___getwin (struct screen * a1, FILE * z);
WINDOW * call_NCURSES_SP_NAME___getwin (struct screen * a1, FILE * z)
{
	T((T_CALLED("NCURSES_SP_NAME(getwin)(%p,%p)"), (const void *)a1, (const void *)z));
	returnWin(NCURSES_SP_NAME(getwin)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___halfdelay (struct screen * a1, int z);
int call_NCURSES_SP_NAME___halfdelay (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(halfdelay)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(halfdelay)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern NCURSES_BOOL call_NCURSES_SP_NAME___has_colors (struct screen * z);
NCURSES_BOOL call_NCURSES_SP_NAME___has_colors (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(has_colors)(%p)"), (const void *)z));
	returnBool(NCURSES_SP_NAME(has_colors)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern NCURSES_BOOL call_NCURSES_SP_NAME___has_ic (struct screen * z);
NCURSES_BOOL call_NCURSES_SP_NAME___has_ic (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(has_ic)(%p)"), (const void *)z));
	returnBool(NCURSES_SP_NAME(has_ic)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern NCURSES_BOOL call_NCURSES_SP_NAME___has_il (struct screen * z);
NCURSES_BOOL call_NCURSES_SP_NAME___has_il (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(has_il)(%p)"), (const void *)z));
	returnBool(NCURSES_SP_NAME(has_il)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___init_color (struct screen * a1, short a2, short a3, short a4, short z);
int call_NCURSES_SP_NAME___init_color (struct screen * a1, short a2, short a3, short a4, short z)
{
	T((T_CALLED("NCURSES_SP_NAME(init_color)(%p,%#lx,%#lx,%#lx,%#lx)"), (const void *)a1, (long)a2, (long)a3, (long)a4, (long)z));
	returnCode(NCURSES_SP_NAME(init_color)(a1, a2, a3, a4, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___init_pair (struct screen * a1, short a2, short a3, short z);
int call_NCURSES_SP_NAME___init_pair (struct screen * a1, short a2, short a3, short z)
{
	T((T_CALLED("NCURSES_SP_NAME(init_pair)(%p,%#lx,%#lx,%#lx)"), (const void *)a1, (long)a2, (long)a3, (long)z));
	returnCode(NCURSES_SP_NAME(init_pair)(a1, a2, a3, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___intrflush (struct screen * a1, WINDOW * a2, NCURSES_BOOL z);
int call_NCURSES_SP_NAME___intrflush (struct screen * a1, WINDOW * a2, NCURSES_BOOL z)
{
	T((T_CALLED("NCURSES_SP_NAME(intrflush)(%p,%p,%#lx)"), (const void *)a1, (const void *)a2, (long)z));
	returnCode(NCURSES_SP_NAME(intrflush)(a1, a2, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern NCURSES_BOOL call_NCURSES_SP_NAME___isendwin (struct screen * z);
NCURSES_BOOL call_NCURSES_SP_NAME___isendwin (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(isendwin)(%p)"), (const void *)z));
	returnBool(NCURSES_SP_NAME(isendwin)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern const char * call_NCURSES_SP_NAME___keyname (struct screen * a1, int z);
const char * call_NCURSES_SP_NAME___keyname (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(keyname)(%p,%d)"), (const void *)a1, z));
	returnCPtr(NCURSES_SP_NAME(keyname)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern char call_NCURSES_SP_NAME___killchar (struct screen * z);
char call_NCURSES_SP_NAME___killchar (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(killchar)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(killchar)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern char * call_NCURSES_SP_NAME___longname (struct screen * z);
char * call_NCURSES_SP_NAME___longname (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(longname)(%p)"), (const void *)z));
	returnPtr(NCURSES_SP_NAME(longname)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___mvcur (struct screen * a1, int a2, int a3, int a4, int z);
int call_NCURSES_SP_NAME___mvcur (struct screen * a1, int a2, int a3, int a4, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(mvcur)(%p,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, z));
	returnCode(NCURSES_SP_NAME(mvcur)(a1, a2, a3, a4, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___napms (struct screen * a1, int z);
int call_NCURSES_SP_NAME___napms (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(napms)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(napms)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern WINDOW * call_NCURSES_SP_NAME___newpad (struct screen * a1, int a2, int z);
WINDOW * call_NCURSES_SP_NAME___newpad (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(newpad)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnWin(NCURSES_SP_NAME(newpad)(a1, a2, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern struct screen * call_NCURSES_SP_NAME___newterm (struct screen * a1, const char * a2, FILE * a3, FILE * z);
struct screen * call_NCURSES_SP_NAME___newterm (struct screen * a1, const char * a2, FILE * a3, FILE * z)
{
	T((T_CALLED("NCURSES_SP_NAME(newterm)(%p,%s,%p,%p)"), (const void *)a1, _nc_visbuf2(1,a2), (const void *)a3, (const void *)z));
	returnSP(NCURSES_SP_NAME(newterm)(a1, a2, a3, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern WINDOW * call_NCURSES_SP_NAME___newwin (struct screen * a1, int a2, int a3, int a4, int z);
WINDOW * call_NCURSES_SP_NAME___newwin (struct screen * a1, int a2, int a3, int a4, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(newwin)(%p,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, z));
	returnWin(NCURSES_SP_NAME(newwin)(a1, a2, a3, a4, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___nl (struct screen * z);
int call_NCURSES_SP_NAME___nl (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(nl)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(nl)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___nocbreak (struct screen * z);
int call_NCURSES_SP_NAME___nocbreak (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(nocbreak)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(nocbreak)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___noecho (struct screen * z);
int call_NCURSES_SP_NAME___noecho (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(noecho)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(noecho)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___nonl (struct screen * z);
int call_NCURSES_SP_NAME___nonl (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(nonl)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(nonl)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern void call_NCURSES_SP_NAME___noqiflush (struct screen * z);
void call_NCURSES_SP_NAME___noqiflush (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(noqiflush)(%p)"), (const void *)z));
	NCURSES_SP_NAME(noqiflush)(z);
	returnVoid;
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___noraw (struct screen * z);
int call_NCURSES_SP_NAME___noraw (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(noraw)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(noraw)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___pair_content (struct screen * a1, short a2, short * a3, short * z);
int call_NCURSES_SP_NAME___pair_content (struct screen * a1, short a2, short * a3, short * z)
{
	T((T_CALLED("NCURSES_SP_NAME(pair_content)(%p,%#lx,%p,%p)"), (const void *)a1, (long)a2, (const void *)a3, (const void *)z));
	returnCode(NCURSES_SP_NAME(pair_content)(a1, a2, a3, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern void call_NCURSES_SP_NAME___qiflush (struct screen * z);
void call_NCURSES_SP_NAME___qiflush (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(qiflush)(%p)"), (const void *)z));
	NCURSES_SP_NAME(qiflush)(z);
	returnVoid;
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___raw (struct screen * z);
int call_NCURSES_SP_NAME___raw (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(raw)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(raw)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___reset_prog_mode (struct screen * z);
int call_NCURSES_SP_NAME___reset_prog_mode (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(reset_prog_mode)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(reset_prog_mode)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___reset_shell_mode (struct screen * z);
int call_NCURSES_SP_NAME___reset_shell_mode (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(reset_shell_mode)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(reset_shell_mode)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___resetty (struct screen * z);
int call_NCURSES_SP_NAME___resetty (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(resetty)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(resetty)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___ripoffline (struct screen * a1, int a2, int(* z)(WINDOW * a3, int));
int call_NCURSES_SP_NAME___ripoffline (struct screen * a1, int a2, int(* z)(WINDOW * a3, int))
{
	return NCURSES_SP_NAME(ripoffline)(a1, a2, z) ;
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___savetty (struct screen * z);
int call_NCURSES_SP_NAME___savetty (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(savetty)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(savetty)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___scr_init (struct screen * a1, const char * z);
int call_NCURSES_SP_NAME___scr_init (struct screen * a1, const char * z)
{
	T((T_CALLED("NCURSES_SP_NAME(scr_init)(%p,%s)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(NCURSES_SP_NAME(scr_init)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___scr_restore (struct screen * a1, const char * z);
int call_NCURSES_SP_NAME___scr_restore (struct screen * a1, const char * z)
{
	T((T_CALLED("NCURSES_SP_NAME(scr_restore)(%p,%s)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(NCURSES_SP_NAME(scr_restore)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___scr_set (struct screen * a1, const char * z);
int call_NCURSES_SP_NAME___scr_set (struct screen * a1, const char * z)
{
	T((T_CALLED("NCURSES_SP_NAME(scr_set)(%p,%s)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(NCURSES_SP_NAME(scr_set)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_attroff (struct screen * a1, const chtype z);
int call_NCURSES_SP_NAME___slk_attroff (struct screen * a1, const chtype z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_attroff)(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(NCURSES_SP_NAME(slk_attroff)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_attron (struct screen * a1, const chtype z);
int call_NCURSES_SP_NAME___slk_attron (struct screen * a1, const chtype z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_attron)(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(NCURSES_SP_NAME(slk_attron)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_attrset (struct screen * a1, const chtype z);
int call_NCURSES_SP_NAME___slk_attrset (struct screen * a1, const chtype z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_attrset)(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(NCURSES_SP_NAME(slk_attrset)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern attr_t call_NCURSES_SP_NAME___slk_attr (struct screen * z);
attr_t call_NCURSES_SP_NAME___slk_attr (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_attr)(%p)"), (const void *)z));
	returnIntAttr((attr_t)NCURSES_SP_NAME(slk_attr)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_attr_set (struct screen * a1, const attr_t a2, short a3, void * z);
int call_NCURSES_SP_NAME___slk_attr_set (struct screen * a1, const attr_t a2, short a3, void * z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_attr_set)(%p,%s,%#lx,%p)"), (const void *)a1, _traceattr2(1,a2), (long)a3, (const void *)z));
	returnCode(NCURSES_SP_NAME(slk_attr_set)(a1, a2, a3, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_clear (struct screen * z);
int call_NCURSES_SP_NAME___slk_clear (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_clear)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(slk_clear)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_color (struct screen * a1, short z);
int call_NCURSES_SP_NAME___slk_color (struct screen * a1, short z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_color)(%p,%#lx)"), (const void *)a1, (long)z));
	returnCode(NCURSES_SP_NAME(slk_color)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_init (struct screen * a1, int z);
int call_NCURSES_SP_NAME___slk_init (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_init)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(slk_init)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern char * call_NCURSES_SP_NAME___slk_label (struct screen * a1, int z);
char * call_NCURSES_SP_NAME___slk_label (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_label)(%p,%d)"), (const void *)a1, z));
	returnPtr(NCURSES_SP_NAME(slk_label)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_noutrefresh (struct screen * z);
int call_NCURSES_SP_NAME___slk_noutrefresh (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_noutrefresh)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(slk_noutrefresh)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_refresh (struct screen * z);
int call_NCURSES_SP_NAME___slk_refresh (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_refresh)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(slk_refresh)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_restore (struct screen * z);
int call_NCURSES_SP_NAME___slk_restore (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_restore)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(slk_restore)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_set (struct screen * a1, int a2, const char * a3, int z);
int call_NCURSES_SP_NAME___slk_set (struct screen * a1, int a2, const char * a3, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_set)(%p,%d,%s,%d)"), (const void *)a1, a2, _nc_visbuf2(2,a3), z));
	returnCode(NCURSES_SP_NAME(slk_set)(a1, a2, a3, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___slk_touch (struct screen * z);
int call_NCURSES_SP_NAME___slk_touch (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(slk_touch)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(slk_touch)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___start_color (struct screen * z);
int call_NCURSES_SP_NAME___start_color (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(start_color)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(start_color)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern chtype call_NCURSES_SP_NAME___termattrs (struct screen * z);
chtype call_NCURSES_SP_NAME___termattrs (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(termattrs)(%p)"), (const void *)z));
	returnChtype(NCURSES_SP_NAME(termattrs)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern char * call_NCURSES_SP_NAME___termname (struct screen * z);
char * call_NCURSES_SP_NAME___termname (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(termname)(%p)"), (const void *)z));
	returnPtr(NCURSES_SP_NAME(termname)(z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___typeahead (struct screen * a1, int z);
int call_NCURSES_SP_NAME___typeahead (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(typeahead)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(typeahead)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___ungetch (struct screen * a1, int z);
int call_NCURSES_SP_NAME___ungetch (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(ungetch)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(ungetch)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern void call_NCURSES_SP_NAME___use_env (struct screen * a1, NCURSES_BOOL z);
void call_NCURSES_SP_NAME___use_env (struct screen * a1, NCURSES_BOOL z)
{
	T((T_CALLED("NCURSES_SP_NAME(use_env)(%p,%#lx)"), (const void *)a1, (long)z));
	NCURSES_SP_NAME(use_env)(a1, z);
	returnVoid;
}
#endif


#if USE_SP_FUNC_SUPPORT

extern void call_NCURSES_SP_NAME___use_tioctl (struct screen * a1, NCURSES_BOOL z);
void call_NCURSES_SP_NAME___use_tioctl (struct screen * a1, NCURSES_BOOL z)
{
	T((T_CALLED("NCURSES_SP_NAME(use_tioctl)(%p,%#lx)"), (const void *)a1, (long)z));
	NCURSES_SP_NAME(use_tioctl)(a1, z);
	returnVoid;
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___vidattr (struct screen * a1, chtype z);
int call_NCURSES_SP_NAME___vidattr (struct screen * a1, chtype z)
{
	T((T_CALLED("NCURSES_SP_NAME(vidattr)(%p,%s)"), (const void *)a1, _tracechtype2(1,z)));
	returnCode(NCURSES_SP_NAME(vidattr)(a1, z));
}
#endif


#if USE_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___vidputs (struct screen * a1, chtype a2, NCURSES_OUTC_sp z);
int call_NCURSES_SP_NAME___vidputs (struct screen * a1, chtype a2, NCURSES_OUTC_sp z)
{
	T((T_CALLED("NCURSES_SP_NAME(vidputs)(%p,%s,%#lx)"), (const void *)a1, _tracechtype2(1,a2), (long)z));
	returnCode(NCURSES_SP_NAME(vidputs)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern char * call_NCURSES_SP_NAME___keybound (struct screen * a1, int a2, int z);
char * call_NCURSES_SP_NAME___keybound (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(keybound)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnPtr(NCURSES_SP_NAME(keybound)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___alloc_pair (struct screen * a1, int a2, int z);
int call_NCURSES_SP_NAME___alloc_pair (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(alloc_pair)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(NCURSES_SP_NAME(alloc_pair)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___assume_default_colors (struct screen * a1, int a2, int z);
int call_NCURSES_SP_NAME___assume_default_colors (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(assume_default_colors)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(NCURSES_SP_NAME(assume_default_colors)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___define_key (struct screen * a1, const char * a2, int z);
int call_NCURSES_SP_NAME___define_key (struct screen * a1, const char * a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(define_key)(%p,%s,%d)"), (const void *)a1, _nc_visbuf2(1,a2), z));
	returnCode(NCURSES_SP_NAME(define_key)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___extended_color_content (struct screen * a1, int a2, int * a3, int * a4, int * z);
int call_NCURSES_SP_NAME___extended_color_content (struct screen * a1, int a2, int * a3, int * a4, int * z)
{
	T((T_CALLED("NCURSES_SP_NAME(extended_color_content)(%p,%d,%p,%p,%p)"), (const void *)a1, a2, (const void *)a3, (const void *)a4, (const void *)z));
	returnCode(NCURSES_SP_NAME(extended_color_content)(a1, a2, a3, a4, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___extended_pair_content (struct screen * a1, int a2, int * a3, int * z);
int call_NCURSES_SP_NAME___extended_pair_content (struct screen * a1, int a2, int * a3, int * z)
{
	T((T_CALLED("NCURSES_SP_NAME(extended_pair_content)(%p,%d,%p,%p)"), (const void *)a1, a2, (const void *)a3, (const void *)z));
	returnCode(NCURSES_SP_NAME(extended_pair_content)(a1, a2, a3, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___extended_slk_color (struct screen * a1, int z);
int call_NCURSES_SP_NAME___extended_slk_color (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(extended_slk_color)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(extended_slk_color)(a1, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___get_escdelay (struct screen * z);
int call_NCURSES_SP_NAME___get_escdelay (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(get_escdelay)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(get_escdelay)(z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___find_pair (struct screen * a1, int a2, int z);
int call_NCURSES_SP_NAME___find_pair (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(find_pair)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(NCURSES_SP_NAME(find_pair)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___free_pair (struct screen * a1, int z);
int call_NCURSES_SP_NAME___free_pair (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(free_pair)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(free_pair)(a1, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___init_extended_color (struct screen * a1, int a2, int a3, int a4, int z);
int call_NCURSES_SP_NAME___init_extended_color (struct screen * a1, int a2, int a3, int a4, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(init_extended_color)(%p,%d,%d,%d,%d)"), (const void *)a1, a2, a3, a4, z));
	returnCode(NCURSES_SP_NAME(init_extended_color)(a1, a2, a3, a4, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___init_extended_pair (struct screen * a1, int a2, int a3, int z);
int call_NCURSES_SP_NAME___init_extended_pair (struct screen * a1, int a2, int a3, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(init_extended_pair)(%p,%d,%d,%d)"), (const void *)a1, a2, a3, z));
	returnCode(NCURSES_SP_NAME(init_extended_pair)(a1, a2, a3, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern NCURSES_BOOL call_NCURSES_SP_NAME___is_term_resized (struct screen * a1, int a2, int z);
NCURSES_BOOL call_NCURSES_SP_NAME___is_term_resized (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(is_term_resized)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnBool(NCURSES_SP_NAME(is_term_resized)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___key_defined (struct screen * a1, const char * z);
int call_NCURSES_SP_NAME___key_defined (struct screen * a1, const char * z)
{
	T((T_CALLED("NCURSES_SP_NAME(key_defined)(%p,%s)"), (const void *)a1, _nc_visbuf2(1,z)));
	returnCode(NCURSES_SP_NAME(key_defined)(a1, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___keyok (struct screen * a1, int a2, NCURSES_BOOL z);
int call_NCURSES_SP_NAME___keyok (struct screen * a1, int a2, NCURSES_BOOL z)
{
	T((T_CALLED("NCURSES_SP_NAME(keyok)(%p,%d,%#lx)"), (const void *)a1, a2, (long)z));
	returnCode(NCURSES_SP_NAME(keyok)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern void call_NCURSES_SP_NAME___nofilter (struct screen * z);
void call_NCURSES_SP_NAME___nofilter (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(nofilter)(%p)"), (const void *)z));
	NCURSES_SP_NAME(nofilter)(z);
	returnVoid;
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern void call_NCURSES_SP_NAME___reset_color_pairs (struct screen * z);
void call_NCURSES_SP_NAME___reset_color_pairs (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(reset_color_pairs)(%p)"), (const void *)z));
	NCURSES_SP_NAME(reset_color_pairs)(z);
	returnVoid;
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___resize_term (struct screen * a1, int a2, int z);
int call_NCURSES_SP_NAME___resize_term (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(resize_term)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(NCURSES_SP_NAME(resize_term)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___resizeterm (struct screen * a1, int a2, int z);
int call_NCURSES_SP_NAME___resizeterm (struct screen * a1, int a2, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(resizeterm)(%p,%d,%d)"), (const void *)a1, a2, z));
	returnCode(NCURSES_SP_NAME(resizeterm)(a1, a2, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___set_escdelay (struct screen * a1, int z);
int call_NCURSES_SP_NAME___set_escdelay (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(set_escdelay)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(set_escdelay)(a1, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___set_tabsize (struct screen * a1, int z);
int call_NCURSES_SP_NAME___set_tabsize (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(set_tabsize)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(set_tabsize)(a1, z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___use_default_colors (struct screen * z);
int call_NCURSES_SP_NAME___use_default_colors (struct screen * z)
{
	T((T_CALLED("NCURSES_SP_NAME(use_default_colors)(%p)"), (const void *)z));
	returnCode(NCURSES_SP_NAME(use_default_colors)(z));
}
#endif


#if USE_EXT_SP_FUNC_SUPPORT

extern int call_NCURSES_SP_NAME___use_legacy_coding (struct screen * a1, int z);
int call_NCURSES_SP_NAME___use_legacy_coding (struct screen * a1, int z)
{
	T((T_CALLED("NCURSES_SP_NAME(use_legacy_coding)(%p,%d)"), (const void *)a1, z));
	returnCode(NCURSES_SP_NAME(use_legacy_coding)(a1, z));
}
#endif



extern NCURSES_BOOL call_mouse_trafo (int * a1, int * a2, NCURSES_BOOL z);
NCURSES_BOOL call_mouse_trafo (int * a1, int * a2, NCURSES_BOOL z)
{
	T((T_CALLED("mouse_trafo(%p,%p,%#lx)"), (const void *)a1, (const void *)a2, (long)z));
	returnBool(mouse_trafo(a1, a2, z));
}
int main(void)
{
 call_addch (0);
 call_addchnstr (0, 0);
 call_addchstr (0);
 call_addnstr (0, 0);
 call_addstr (0);
 call_attroff (0);
 call_attron (0);
 call_attrset (0);
 call_attr_get (0, 0, 0);
 call_attr_off (0, 0);
 call_attr_on (0, 0);
 call_attr_set (0, 0, 0);
 call_baudrate ();
 call_beep ();
 call_bkgd (0);
 call_bkgdset (0);
 call_border (0, 0, 0, 0, 0, 0, 0, 0);
 call_box (0, 0, 0);
 call_can_change_color ();
 call_cbreak ();
 call_chgat (0, 0, 0, 0);
 call_clear ();
 call_clearok (0, 0);
 call_clrtobot ();
 call_clrtoeol ();
 call_color_content (0, 0, 0, 0);
 call_color_set (0, 0);
 call_COLOR_PAIR (0);
 call_copywin (0, 0, 0, 0, 0, 0, 0, 0, 0);
 call_curs_set (0);
 call_def_prog_mode ();
 call_def_shell_mode ();
 call_delay_output (0);
 call_delch ();
 call_delscreen (0);
 call_delwin (0);
 call_deleteln ();
 call_derwin (0, 0, 0, 0, 0);
 call_doupdate ();
 call_dupwin (0);
 call_echo ();
 call_echochar (0);
 call_erase ();
 call_endwin ();
 call_erasechar ();
 call_filter ();
 call_flash ();
 call_flushinp ();
 call_getbkgd (0);
 call_getch ();
 call_getnstr (0, 0);
 call_getstr (0);
 call_getwin (0);
 call_halfdelay (0);
 call_has_colors ();
 call_has_ic ();
 call_has_il ();
 call_hline (0, 0);
 call_idcok (0, 0);
 call_idlok (0, 0);
 call_immedok (0, 0);
 call_inch ();
 call_inchnstr (0, 0);
 call_inchstr (0);
 call_initscr ();
 call_init_color (0, 0, 0, 0);
 call_init_pair (0, 0, 0);
 call_innstr (0, 0);
 call_insch (0);
 call_insdelln (0);
 call_insertln ();
 call_insnstr (0, 0);
 call_insstr (0);
 call_instr (0);
 call_intrflush (0, 0);
 call_isendwin ();
 call_is_linetouched (0, 0);
 call_is_wintouched (0);
 call_keyname (0);
 call_keypad (0, 0);
 call_killchar ();
 call_leaveok (0, 0);
 call_longname ();
 call_meta (0, 0);
 call_move (0, 0);
 call_mvaddch (0, 0, 0);
 call_mvaddchnstr (0, 0, 0, 0);
 call_mvaddchstr (0, 0, 0);
 call_mvaddnstr (0, 0, 0, 0);
 call_mvaddstr (0, 0, 0);
 call_mvchgat (0, 0, 0, 0, 0, 0);
 call_mvcur (0, 0, 0, 0);
 call_mvdelch (0, 0);
 call_mvderwin (0, 0, 0);
 call_mvgetch (0, 0);
 call_mvgetnstr (0, 0, 0, 0);
 call_mvgetstr (0, 0, 0);
 call_mvhline (0, 0, 0, 0);
 call_mvinch (0, 0);
 call_mvinchnstr (0, 0, 0, 0);
 call_mvinchstr (0, 0, 0);
 call_mvinnstr (0, 0, 0, 0);
 call_mvinsch (0, 0, 0);
 call_mvinsnstr (0, 0, 0, 0);
 call_mvinsstr (0, 0, 0);
 call_mvinstr (0, 0, 0);
 call_mvvline (0, 0, 0, 0);
 call_mvwaddch (0, 0, 0, 0);
 call_mvwaddchnstr (0, 0, 0, 0, 0);
 call_mvwaddchstr (0, 0, 0, 0);
 call_mvwaddnstr (0, 0, 0, 0, 0);
 call_mvwaddstr (0, 0, 0, 0);
 call_mvwchgat (0, 0, 0, 0, 0, 0, 0);
 call_mvwdelch (0, 0, 0);
 call_mvwgetch (0, 0, 0);
 call_mvwgetnstr (0, 0, 0, 0, 0);
 call_mvwgetstr (0, 0, 0, 0);
 call_mvwhline (0, 0, 0, 0, 0);
 call_mvwin (0, 0, 0);
 call_mvwinch (0, 0, 0);
 call_mvwinchnstr (0, 0, 0, 0, 0);
 call_mvwinchstr (0, 0, 0, 0);
 call_mvwinnstr (0, 0, 0, 0, 0);
 call_mvwinsch (0, 0, 0, 0);
 call_mvwinsnstr (0, 0, 0, 0, 0);
 call_mvwinsstr (0, 0, 0, 0);
 call_mvwinstr (0, 0, 0, 0);
 call_mvwvline (0, 0, 0, 0, 0);
 call_napms (0);
 call_newpad (0, 0);
 call_newterm (0, 0, 0);
 call_newwin (0, 0, 0, 0);
 call_nl ();
 call_nocbreak ();
 call_nodelay (0, 0);
 call_noecho ();
 call_nonl ();
 call_noqiflush ();
 call_noraw ();
 call_notimeout (0, 0);
 call_overlay (0, 0);
 call_overwrite (0, 0);
 call_pair_content (0, 0, 0);
 call_PAIR_NUMBER (0);
 call_pechochar (0, 0);
 call_pnoutrefresh (0, 0, 0, 0, 0, 0, 0);
 call_prefresh (0, 0, 0, 0, 0, 0, 0);
 call_putwin (0, 0);
 call_qiflush ();
 call_raw ();
 call_redrawwin (0);
 call_refresh ();
 call_resetty ();
 call_reset_prog_mode ();
 call_reset_shell_mode ();
 call_ripoffline (0,0);
 call_savetty ();
 call_scr_dump (0);
 call_scr_init (0);
 call_scrl (0);
 call_scroll (0);
 call_scrollok (0, 0);
 call_scr_restore (0);
 call_scr_set (0);
 call_setscrreg (0, 0);
 call_set_term (0);
 call_slk_attroff (0);
#if USE_WIDEC_SUPPORT
 call_slk_attr_off (0, 0);
#endif
 call_slk_attron (0);
#if USE_WIDEC_SUPPORT
 call_slk_attr_on (0, 0);
#endif
 call_slk_attrset (0);
 call_slk_attr ();
 call_slk_attr_set (0, 0, 0);
 call_slk_clear ();
 call_slk_color (0);
 call_slk_init (0);
 call_slk_label (0);
 call_slk_noutrefresh ();
 call_slk_refresh ();
 call_slk_restore ();
 call_slk_set (0, 0, 0);
 call_slk_touch ();
 call_standout ();
 call_standend ();
 call_start_color ();
 call_subpad (0, 0, 0, 0, 0);
 call_subwin (0, 0, 0, 0, 0);
 call_syncok (0, 0);
 call_termattrs ();
 call_termname ();
 call_timeout (0);
 call_touchline (0, 0, 0);
 call_touchwin (0);
 call_typeahead (0);
 call_ungetch (0);
 call_untouchwin (0);
 call_use_env (0);
 call_use_tioctl (0);
 call_vidattr (0);
 call_vidputs (0, 0);
 call_vline (0, 0);
 call_waddch (0, 0);
 call_waddchnstr (0, 0, 0);
 call_waddchstr (0, 0);
 call_waddnstr (0, 0, 0);
 call_waddstr (0, 0);
 call_wattron (0, 0);
 call_wattroff (0, 0);
 call_wattrset (0, 0);
 call_wattr_get (0, 0, 0, 0);
 call_wattr_on (0, 0, 0);
 call_wattr_off (0, 0, 0);
 call_wattr_set (0, 0, 0, 0);
 call_wbkgd (0, 0);
 call_wbkgdset (0, 0);
 call_wborder (0, 0, 0, 0, 0, 0, 0, 0, 0);
 call_wchgat (0, 0, 0, 0, 0);
 call_wclear (0);
 call_wclrtobot (0);
 call_wclrtoeol (0);
 call_wcolor_set (0, 0, 0);
 call_wcursyncup (0);
 call_wdelch (0);
 call_wdeleteln (0);
 call_wechochar (0, 0);
 call_werase (0);
 call_wgetch (0);
 call_wgetnstr (0, 0, 0);
 call_wgetstr (0, 0);
 call_whline (0, 0, 0);
 call_winch (0);
 call_winchnstr (0, 0, 0);
 call_winchstr (0, 0);
 call_winnstr (0, 0, 0);
 call_winsch (0, 0);
 call_winsdelln (0, 0);
 call_winsertln (0);
 call_winsnstr (0, 0, 0);
 call_winsstr (0, 0);
 call_winstr (0, 0);
 call_wmove (0, 0, 0);
 call_wnoutrefresh (0);
 call_wredrawln (0, 0, 0);
 call_wrefresh (0);
 call_wscrl (0, 0);
 call_wsetscrreg (0, 0, 0);
 call_wstandout (0);
 call_wstandend (0);
 call_wsyncdown (0);
 call_wsyncup (0);
 call_wtimeout (0, 0);
 call_wtouchln (0, 0, 0, 0);
 call_wvline (0, 0, 0);
 call_tigetflag (0);
 call_tigetnum (0);
 call_tigetstr (0);
 call_putp (0);
 call_getattrs (0);
 call_getcurx (0);
 call_getcury (0);
 call_getbegx (0);
 call_getbegy (0);
 call_getmaxx (0);
 call_getmaxy (0);
 call_getparx (0);
 call_getpary (0);
 call_wgetparent (0);
 call_is_cleared (0);
 call_is_idcok (0);
 call_is_idlok (0);
 call_is_immedok (0);
 call_is_keypad (0);
 call_is_leaveok (0);
 call_is_nodelay (0);
 call_is_notimeout (0);
 call_is_pad (0);
 call_is_scrollok (0);
 call_is_subwin (0);
 call_is_syncok (0);
 call_wgetdelay (0);
 call_wgetscrreg (0, 0, 0);
#if USE_SP_FUNC_SUPPORT
 call_new_prescr ();
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___baudrate (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___beep (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___can_change_color (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___cbreak (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___curs_set (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___color_content (0, 0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___def_prog_mode (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___def_shell_mode (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___delay_output (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___doupdate (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___echo (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___endwin (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___erasechar (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___filter (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___flash (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___flushinp (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___getwin (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___halfdelay (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___has_colors (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___has_ic (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___has_il (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___init_color (0, 0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___init_pair (0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___intrflush (0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___isendwin (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___keyname (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___killchar (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___longname (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___mvcur (0, 0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___napms (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___newpad (0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___newterm (0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___newwin (0, 0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___nl (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___nocbreak (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___noecho (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___nonl (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___noqiflush (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___noraw (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___pair_content (0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___qiflush (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___raw (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___reset_prog_mode (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___reset_shell_mode (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___resetty (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___ripoffline (0, 0,0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___savetty (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___scr_init (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___scr_restore (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___scr_set (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_attroff (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_attron (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_attrset (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_attr (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_attr_set (0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_clear (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_color (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_init (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_label (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_noutrefresh (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_refresh (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_restore (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_set (0, 0, 0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___slk_touch (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___start_color (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___termattrs (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___termname (0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___typeahead (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___ungetch (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___use_env (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___use_tioctl (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___vidattr (0, 0);
#endif
#if USE_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___vidputs (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___keybound (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___alloc_pair (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___assume_default_colors (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___define_key (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___extended_color_content (0, 0, 0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___extended_pair_content (0, 0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___extended_slk_color (0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___get_escdelay (0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___find_pair (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___free_pair (0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___init_extended_color (0, 0, 0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___init_extended_pair (0, 0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___is_term_resized (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___key_defined (0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___keyok (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___nofilter (0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___reset_color_pairs (0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___resize_term (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___resizeterm (0, 0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___set_escdelay (0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___set_tabsize (0, 0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___use_default_colors (0);
#endif
#if USE_EXT_SP_FUNC_SUPPORT
 call_NCURSES_SP_NAME___use_legacy_coding (0, 0);
#endif
 call_mouse_trafo (0, 0, 0);
 return 0;
}
