/****************************************************************************
 * Copyright (c) 2008-2013,2015 Free Software Foundation, Inc.              *
 *                                                                          *
 * Permission is hereby granted, free of charge, to any person obtaining a  *
 * copy of this software and associated documentation files (the            *
 * "Software"), to deal in the Software without restriction, including      *
 * without limitation the rights to use, copy, modify, merge, publish,      *
 * distribute, distribute with modifications, sublicense, and/or sell       *
 * copies of the Software, and to permit persons to whom the Software is    *
 * furnished to do so, subject to the following conditions:                 *
 *                                                                          *
 * The above copyright notice and this permission notice shall be included  *
 * in all copies or substantial portions of the Software.                   *
 *                                                                          *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
 *                                                                          *
 * Except as contained in this notice, the name(s) of the above copyright   *
 * holders shall not be used in advertising or otherwise to promote the     *
 * sale, use or other dealings in this Software without prior written       *
 * authorization.                                                           *
 ****************************************************************************/

/****************************************************************************
 *  Author: Thomas E. Dickey       2008-on                                  *
 ****************************************************************************/
/* LINTLIBRARY */

/* ./tty/hardscroll.c */

#include <curses.priv.h>

#undef _nc_oldnums
int	*_nc_oldnums;

#undef _nc_scroll_optimize_sp
void	_nc_scroll_optimize_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_scroll_optimize
void	_nc_scroll_optimize(void)
		{ /* void */ }

#undef _nc_linedump_sp
void	_nc_linedump_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_linedump
void	_nc_linedump(void)
		{ /* void */ }

/* ./tty/hashmap.c */

#undef _nc_hash_map_sp
void	_nc_hash_map_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_hash_map
void	_nc_hash_map(void)
		{ /* void */ }

#undef _nc_make_oldhash_sp
void	_nc_make_oldhash_sp(
		SCREEN	*sp, 
		int	i)
		{ /* void */ }

#undef _nc_make_oldhash
void	_nc_make_oldhash(
		int	i)
		{ /* void */ }

#undef _nc_scroll_oldhash_sp
void	_nc_scroll_oldhash_sp(
		SCREEN	*sp, 
		int	n, 
		int	top, 
		int	bot)
		{ /* void */ }

#undef _nc_scroll_oldhash
void	_nc_scroll_oldhash(
		int	n, 
		int	top, 
		int	bot)
		{ /* void */ }

/* ./base/lib_addch.c */

#undef _nc_render
chtype	_nc_render(
		WINDOW	*win, 
		chtype	ch)
		{ return(*(chtype *)0); }

#undef _nc_waddch_nosync
int	_nc_waddch_nosync(
		WINDOW	*win, 
		const chtype c)
		{ return(*(int *)0); }

#undef waddch
int	waddch(
		WINDOW	*win, 
		const chtype ch)
		{ return(*(int *)0); }

#undef wechochar
int	wechochar(
		WINDOW	*win, 
		const chtype ch)
		{ return(*(int *)0); }

/* ./base/lib_addstr.c */

#undef waddnstr
int	waddnstr(
		WINDOW	*win, 
		const char *astr, 
		int	n)
		{ return(*(int *)0); }

#undef waddchnstr
int	waddchnstr(
		WINDOW	*win, 
		const chtype *astr, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_beep.c */

#undef beep_sp
int	beep_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef beep
int	beep(void)
		{ return(*(int *)0); }

/* ./base/lib_bkgd.c */

#undef wbkgdset
void	wbkgdset(
		WINDOW	*win, 
		chtype	ch)
		{ /* void */ }

#undef wbkgd
int	wbkgd(
		WINDOW	*win, 
		chtype	ch)
		{ return(*(int *)0); }

/* ./base/lib_box.c */

#undef wborder
int	wborder(
		WINDOW	*win, 
		chtype	ls, 
		chtype	rs, 
		chtype	ts, 
		chtype	bs, 
		chtype	tl, 
		chtype	tr, 
		chtype	bl, 
		chtype	br)
		{ return(*(int *)0); }

/* ./base/lib_chgat.c */

#undef wchgat
int	wchgat(
		WINDOW	*win, 
		int	n, 
		attr_t	attr, 
		short	color, 
		const void *opts)
		{ return(*(int *)0); }

/* ./base/lib_clear.c */

#undef wclear
int	wclear(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_clearok.c */

#undef clearok
int	clearok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/lib_clrbot.c */

#undef wclrtobot
int	wclrtobot(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_clreol.c */

#undef wclrtoeol
int	wclrtoeol(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_color.c */

#undef _nc_COLOR_PAIRS
int	_nc_COLOR_PAIRS(void)
		{ return(*(int *)0); }

#undef _nc_COLORS
int	_nc_COLORS(void)
		{ return(*(int *)0); }

#undef _nc_reset_colors_sp
NCURSES_BOOL _nc_reset_colors_sp(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_reset_colors
NCURSES_BOOL _nc_reset_colors(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef start_color_sp
int	start_color_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef start_color
int	start_color(void)
		{ return(*(int *)0); }

#undef init_pair_sp
int	init_pair_sp(
		SCREEN	*sp, 
		short	pair, 
		short	f, 
		short	b)
		{ return(*(int *)0); }

#undef init_pair
int	init_pair(
		short	pair, 
		short	f, 
		short	b)
		{ return(*(int *)0); }

#undef init_color_sp
int	init_color_sp(
		SCREEN	*sp, 
		short	color, 
		short	r, 
		short	g, 
		short	b)
		{ return(*(int *)0); }

#undef init_color
int	init_color(
		short	color, 
		short	r, 
		short	g, 
		short	b)
		{ return(*(int *)0); }

#undef can_change_color_sp
NCURSES_BOOL can_change_color_sp(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef can_change_color
NCURSES_BOOL can_change_color(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_colors_sp
NCURSES_BOOL has_colors_sp(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_colors
NCURSES_BOOL has_colors(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef color_content_sp
int	color_content_sp(
		SCREEN	*sp, 
		short	color, 
		short	*r, 
		short	*g, 
		short	*b)
		{ return(*(int *)0); }

#undef color_content
int	color_content(
		short	color, 
		short	*r, 
		short	*g, 
		short	*b)
		{ return(*(int *)0); }

#undef pair_content_sp
int	pair_content_sp(
		SCREEN	*sp, 
		short	pair, 
		short	*f, 
		short	*b)
		{ return(*(int *)0); }

#undef pair_content
int	pair_content(
		short	pair, 
		short	*f, 
		short	*b)
		{ return(*(int *)0); }

#undef _nc_do_color_sp
void	_nc_do_color_sp(
		SCREEN	*sp, 
		int	old_pair, 
		int	pair, 
		int	reverse, 
		NCURSES_OUTC_sp outc)
		{ /* void */ }

#undef _nc_do_color
void	_nc_do_color(
		int	old_pair, 
		int	pair, 
		int	reverse, 
		NCURSES_OUTC outc)
		{ /* void */ }

/* ./base/lib_colorset.c */

#undef wcolor_set
int	wcolor_set(
		WINDOW	*win, 
		short	color_pair_number, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_delch.c */

#undef wdelch
int	wdelch(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_delwin.c */

#undef delwin
int	delwin(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_echo.c */

#undef echo_sp
int	echo_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef echo
int	echo(void)
		{ return(*(int *)0); }

#undef noecho_sp
int	noecho_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef noecho
int	noecho(void)
		{ return(*(int *)0); }

/* ./base/lib_endwin.c */

#undef endwin_sp
int	endwin_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef endwin
int	endwin(void)
		{ return(*(int *)0); }

/* ./base/lib_erase.c */

#undef werase
int	werase(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_flash.c */

#undef flash_sp
int	flash_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef flash
int	flash(void)
		{ return(*(int *)0); }

/* ./lib_gen.c */

#undef addch
int	(addch)(
		const chtype z)
		{ return(*(int *)0); }

#undef addchnstr
int	(addchnstr)(
		const chtype *a1, 
		int	z)
		{ return(*(int *)0); }

#undef addchstr
int	(addchstr)(
		const chtype *z)
		{ return(*(int *)0); }

#undef addnstr
int	(addnstr)(
		const char *a1, 
		int	z)
		{ return(*(int *)0); }

#undef addstr
int	(addstr)(
		const char *z)
		{ return(*(int *)0); }

#undef attroff
int	(attroff)(
		NCURSES_ATTR_T	z)
		{ return(*(int *)0); }

#undef attron
int	(attron)(
		NCURSES_ATTR_T	z)
		{ return(*(int *)0); }

#undef attrset
int	(attrset)(
		NCURSES_ATTR_T	z)
		{ return(*(int *)0); }

#undef attr_get
int	(attr_get)(
		attr_t	*a1, 
		short	*a2, 
		void	*z)
		{ return(*(int *)0); }

#undef attr_off
int	(attr_off)(
		attr_t	a1, 
		void	*z)
		{ return(*(int *)0); }

#undef attr_on
int	(attr_on)(
		attr_t	a1, 
		void	*z)
		{ return(*(int *)0); }

#undef attr_set
int	(attr_set)(
		attr_t	a1, 
		short	a2, 
		void	*z)
		{ return(*(int *)0); }

#undef bkgd
int	(bkgd)(
		chtype	z)
		{ return(*(int *)0); }

#undef bkgdset
void	(bkgdset)(
		chtype	z)
		{ /* void */ }

#undef border
int	(border)(
		chtype	a1, 
		chtype	a2, 
		chtype	a3, 
		chtype	a4, 
		chtype	a5, 
		chtype	a6, 
		chtype	a7, 
		chtype	z)
		{ return(*(int *)0); }

#undef box
int	(box)(
		WINDOW	*a1, 
		chtype	a2, 
		chtype	z)
		{ return(*(int *)0); }

#undef chgat
int	(chgat)(
		int	a1, 
		attr_t	a2, 
		short	a3, 
		const void *z)
		{ return(*(int *)0); }

#undef clear
int	(clear)(void)
		{ return(*(int *)0); }

#undef clrtobot
int	(clrtobot)(void)
		{ return(*(int *)0); }

#undef clrtoeol
int	(clrtoeol)(void)
		{ return(*(int *)0); }

#undef color_set
int	(color_set)(
		short	a1, 
		void	*z)
		{ return(*(int *)0); }

#undef COLOR_PAIR
int	(COLOR_PAIR)(
		int	z)
		{ return(*(int *)0); }

#undef delch
int	(delch)(void)
		{ return(*(int *)0); }

#undef deleteln
int	(deleteln)(void)
		{ return(*(int *)0); }

#undef echochar
int	(echochar)(
		const chtype z)
		{ return(*(int *)0); }

#undef erase
int	(erase)(void)
		{ return(*(int *)0); }

#undef getbkgd
chtype	(getbkgd)(
		WINDOW	*z)
		{ return(*(chtype *)0); }

#undef getch
int	(getch)(void)
		{ return(*(int *)0); }

#undef getnstr
int	(getnstr)(
		char	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef getstr
int	(getstr)(
		char	*z)
		{ return(*(int *)0); }

#undef hline
int	(hline)(
		chtype	a1, 
		int	z)
		{ return(*(int *)0); }

#undef inch
chtype	(inch)(void)
		{ return(*(chtype *)0); }

#undef inchnstr
int	(inchnstr)(
		chtype	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef inchstr
int	(inchstr)(
		chtype	*z)
		{ return(*(int *)0); }

#undef innstr
int	(innstr)(
		char	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef insch
int	(insch)(
		chtype	z)
		{ return(*(int *)0); }

#undef insdelln
int	(insdelln)(
		int	z)
		{ return(*(int *)0); }

#undef insertln
int	(insertln)(void)
		{ return(*(int *)0); }

#undef insnstr
int	(insnstr)(
		const char *a1, 
		int	z)
		{ return(*(int *)0); }

#undef insstr
int	(insstr)(
		const char *z)
		{ return(*(int *)0); }

#undef instr
int	(instr)(
		char	*z)
		{ return(*(int *)0); }

#undef move
int	(move)(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef mvaddch
int	(mvaddch)(
		int	a1, 
		int	a2, 
		const chtype z)
		{ return(*(int *)0); }

#undef mvaddchnstr
int	(mvaddchnstr)(
		int	a1, 
		int	a2, 
		const chtype *a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvaddchstr
int	(mvaddchstr)(
		int	a1, 
		int	a2, 
		const chtype *z)
		{ return(*(int *)0); }

#undef mvaddnstr
int	(mvaddnstr)(
		int	a1, 
		int	a2, 
		const char *a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvaddstr
int	(mvaddstr)(
		int	a1, 
		int	a2, 
		const char *z)
		{ return(*(int *)0); }

#undef mvchgat
int	(mvchgat)(
		int	a1, 
		int	a2, 
		int	a3, 
		attr_t	a4, 
		short	a5, 
		const void *z)
		{ return(*(int *)0); }

#undef mvdelch
int	(mvdelch)(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef mvgetch
int	(mvgetch)(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef mvgetnstr
int	(mvgetnstr)(
		int	a1, 
		int	a2, 
		char	*a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvgetstr
int	(mvgetstr)(
		int	a1, 
		int	a2, 
		char	*z)
		{ return(*(int *)0); }

#undef mvhline
int	(mvhline)(
		int	a1, 
		int	a2, 
		chtype	a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinch
chtype	(mvinch)(
		int	a1, 
		int	z)
		{ return(*(chtype *)0); }

#undef mvinchnstr
int	(mvinchnstr)(
		int	a1, 
		int	a2, 
		chtype	*a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinchstr
int	(mvinchstr)(
		int	a1, 
		int	a2, 
		chtype	*z)
		{ return(*(int *)0); }

#undef mvinnstr
int	(mvinnstr)(
		int	a1, 
		int	a2, 
		char	*a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinsch
int	(mvinsch)(
		int	a1, 
		int	a2, 
		chtype	z)
		{ return(*(int *)0); }

#undef mvinsnstr
int	(mvinsnstr)(
		int	a1, 
		int	a2, 
		const char *a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvinsstr
int	(mvinsstr)(
		int	a1, 
		int	a2, 
		const char *z)
		{ return(*(int *)0); }

#undef mvinstr
int	(mvinstr)(
		int	a1, 
		int	a2, 
		char	*z)
		{ return(*(int *)0); }

#undef mvvline
int	(mvvline)(
		int	a1, 
		int	a2, 
		chtype	a3, 
		int	z)
		{ return(*(int *)0); }

#undef mvwaddch
int	(mvwaddch)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const chtype z)
		{ return(*(int *)0); }

#undef mvwaddchnstr
int	(mvwaddchnstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const chtype *a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwaddchstr
int	(mvwaddchstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const chtype *z)
		{ return(*(int *)0); }

#undef mvwaddnstr
int	(mvwaddnstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwaddstr
int	(mvwaddstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *z)
		{ return(*(int *)0); }

#undef mvwchgat
int	(mvwchgat)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		int	a4, 
		attr_t	a5, 
		short	a6, 
		const void *z)
		{ return(*(int *)0); }

#undef mvwdelch
int	(mvwdelch)(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(int *)0); }

#undef mvwgetch
int	(mvwgetch)(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(int *)0); }

#undef mvwgetnstr
int	(mvwgetnstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwgetstr
int	(mvwgetstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*z)
		{ return(*(int *)0); }

#undef mvwhline
int	(mvwhline)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinch
chtype	(mvwinch)(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(chtype *)0); }

#undef mvwinchnstr
int	(mvwinchnstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	*a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinchstr
int	(mvwinchstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	*z)
		{ return(*(int *)0); }

#undef mvwinnstr
int	(mvwinnstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinsch
int	(mvwinsch)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	z)
		{ return(*(int *)0); }

#undef mvwinsnstr
int	(mvwinsnstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *a4, 
		int	z)
		{ return(*(int *)0); }

#undef mvwinsstr
int	(mvwinsstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		const char *z)
		{ return(*(int *)0); }

#undef mvwinstr
int	(mvwinstr)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		char	*z)
		{ return(*(int *)0); }

#undef mvwvline
int	(mvwvline)(
		WINDOW	*a1, 
		int	a2, 
		int	a3, 
		chtype	a4, 
		int	z)
		{ return(*(int *)0); }

#undef PAIR_NUMBER
int	(PAIR_NUMBER)(
		int	z)
		{ return(*(int *)0); }

#undef redrawwin
int	(redrawwin)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef refresh
int	(refresh)(void)
		{ return(*(int *)0); }

#undef scrl
int	(scrl)(
		int	z)
		{ return(*(int *)0); }

#undef scroll
int	(scroll)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef setscrreg
int	(setscrreg)(
		int	a1, 
		int	z)
		{ return(*(int *)0); }

#undef standout
int	(standout)(void)
		{ return(*(int *)0); }

#undef standend
int	(standend)(void)
		{ return(*(int *)0); }

#undef timeout
void	(timeout)(
		int	z)
		{ /* void */ }

#undef touchline
int	(touchline)(
		WINDOW	*a1, 
		int	a2, 
		int	z)
		{ return(*(int *)0); }

#undef touchwin
int	(touchwin)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef untouchwin
int	(untouchwin)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef vline
int	(vline)(
		chtype	a1, 
		int	z)
		{ return(*(int *)0); }

#undef vw_printw
int	(vw_printw)(
		WINDOW	*a1, 
		const char *a2, 
		va_list	z)
		{ return(*(int *)0); }

#undef vw_scanw
int	(vw_scanw)(
		WINDOW	*a1, 
		const char *a2, 
		va_list	z)
		{ return(*(int *)0); }

#undef waddchstr
int	(waddchstr)(
		WINDOW	*a1, 
		const chtype *z)
		{ return(*(int *)0); }

#undef waddstr
int	(waddstr)(
		WINDOW	*a1, 
		const char *z)
		{ return(*(int *)0); }

#undef wattron
int	(wattron)(
		WINDOW	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef wattroff
int	(wattroff)(
		WINDOW	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef wattrset
int	(wattrset)(
		WINDOW	*a1, 
		int	z)
		{ return(*(int *)0); }

#undef wattr_get
int	(wattr_get)(
		WINDOW	*a1, 
		attr_t	*a2, 
		short	*a3, 
		void	*z)
		{ return(*(int *)0); }

#undef wattr_set
int	(wattr_set)(
		WINDOW	*a1, 
		attr_t	a2, 
		short	a3, 
		void	*z)
		{ return(*(int *)0); }

#undef wdeleteln
int	(wdeleteln)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef wgetstr
int	(wgetstr)(
		WINDOW	*a1, 
		char	*z)
		{ return(*(int *)0); }

#undef winchstr
int	(winchstr)(
		WINDOW	*a1, 
		chtype	*z)
		{ return(*(int *)0); }

#undef winsertln
int	(winsertln)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef winsstr
int	(winsstr)(
		WINDOW	*a1, 
		const char *z)
		{ return(*(int *)0); }

#undef winstr
int	(winstr)(
		WINDOW	*a1, 
		char	*z)
		{ return(*(int *)0); }

#undef wstandout
int	(wstandout)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef wstandend
int	(wstandend)(
		WINDOW	*z)
		{ return(*(int *)0); }

#undef getattrs
int	(getattrs)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getcurx
int	(getcurx)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getcury
int	(getcury)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getbegx
int	(getbegx)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getbegy
int	(getbegy)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getmaxx
int	(getmaxx)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getmaxy
int	(getmaxy)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getparx
int	(getparx)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef getpary
int	(getpary)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef wgetparent
WINDOW	*(wgetparent)(
		const WINDOW *z)
		{ return(*(WINDOW **)0); }

#undef is_cleared
NCURSES_BOOL (is_cleared)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_idcok
NCURSES_BOOL (is_idcok)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_idlok
NCURSES_BOOL (is_idlok)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_immedok
NCURSES_BOOL (is_immedok)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_keypad
NCURSES_BOOL (is_keypad)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_leaveok
NCURSES_BOOL (is_leaveok)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_nodelay
NCURSES_BOOL (is_nodelay)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_notimeout
NCURSES_BOOL (is_notimeout)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_pad
NCURSES_BOOL (is_pad)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_scrollok
NCURSES_BOOL (is_scrollok)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_subwin
NCURSES_BOOL (is_subwin)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_syncok
NCURSES_BOOL (is_syncok)(
		const WINDOW *z)
		{ return(*(NCURSES_BOOL *)0); }

#undef wgetdelay
int	(wgetdelay)(
		const WINDOW *z)
		{ return(*(int *)0); }

#undef wgetscrreg
int	(wgetscrreg)(
		const WINDOW *a1, 
		int	*a2, 
		int	*z)
		{ return(*(int *)0); }

#undef mouse_trafo
NCURSES_BOOL (mouse_trafo)(
		int	*a1, 
		int	*a2, 
		NCURSES_BOOL z)
		{ return(*(NCURSES_BOOL *)0); }

/* ./base/lib_getch.c */

#undef _nc_ESCDELAY
int	_nc_ESCDELAY(void)
		{ return(*(int *)0); }

#undef _nc_ptr_Escdelay
int	*_nc_ptr_Escdelay(
		SCREEN	*sp)
		{ return(*(int **)0); }

#undef set_escdelay_sp
int	set_escdelay_sp(
		SCREEN	*sp, 
		int	value)
		{ return(*(int *)0); }

#undef set_escdelay
int	set_escdelay(
		int	value)
		{ return(*(int *)0); }

#undef get_escdelay_sp
int	get_escdelay_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef get_escdelay
int	get_escdelay(void)
		{ return(*(int *)0); }

#undef _nc_wgetch
int	_nc_wgetch(
		WINDOW	*win, 
		int	*result, 
		int	use_meta)
		{ return(*(int *)0); }

#undef wgetch
int	wgetch(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_getstr.c */

#undef wgetnstr
int	wgetnstr(
		WINDOW	*win, 
		char	*str, 
		int	maxlen)
		{ return(*(int *)0); }

/* ./base/lib_hline.c */

#undef whline
int	whline(
		WINDOW	*win, 
		chtype	ch, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_immedok.c */

#undef immedok
void	immedok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ /* void */ }

/* ./base/lib_inchstr.c */

#undef winchnstr
int	winchnstr(
		WINDOW	*win, 
		chtype	*str, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_initscr.c */

#undef initscr
WINDOW	*initscr(void)
		{ return(*(WINDOW **)0); }

/* ./base/lib_insch.c */

#undef _nc_insert_ch
int	_nc_insert_ch(
		SCREEN	*sp, 
		WINDOW	*win, 
		chtype	ch)
		{ return(*(int *)0); }

#undef winsch
int	winsch(
		WINDOW	*win, 
		chtype	c)
		{ return(*(int *)0); }

/* ./base/lib_insdel.c */

#undef winsdelln
int	winsdelln(
		WINDOW	*win, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_insnstr.c */

#undef winsnstr
int	winsnstr(
		WINDOW	*win, 
		const char *s, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_instr.c */

#undef winnstr
int	winnstr(
		WINDOW	*win, 
		char	*str, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_isendwin.c */

#undef isendwin_sp
NCURSES_BOOL isendwin_sp(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef isendwin
NCURSES_BOOL isendwin(void)
		{ return(*(NCURSES_BOOL *)0); }

/* ./base/lib_leaveok.c */

#undef leaveok
int	leaveok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/lib_mouse.c */

#undef getmouse_sp
int	getmouse_sp(
		SCREEN	*sp, 
		MEVENT	*aevent)
		{ return(*(int *)0); }

#undef getmouse
int	getmouse(
		MEVENT	*aevent)
		{ return(*(int *)0); }

#undef ungetmouse_sp
int	ungetmouse_sp(
		SCREEN	*sp, 
		MEVENT	*aevent)
		{ return(*(int *)0); }

#undef ungetmouse
int	ungetmouse(
		MEVENT	*aevent)
		{ return(*(int *)0); }

#undef mousemask_sp
mmask_t	mousemask_sp(
		SCREEN	*sp, 
		mmask_t	newmask, 
		mmask_t	*oldmask)
		{ return(*(mmask_t *)0); }

#undef mousemask
mmask_t	mousemask(
		mmask_t	newmask, 
		mmask_t	*oldmask)
		{ return(*(mmask_t *)0); }

#undef wenclose
NCURSES_BOOL wenclose(
		const WINDOW *win, 
		int	y, 
		int	x)
		{ return(*(NCURSES_BOOL *)0); }

#undef mouseinterval_sp
int	mouseinterval_sp(
		SCREEN	*sp, 
		int	maxclick)
		{ return(*(int *)0); }

#undef mouseinterval
int	mouseinterval(
		int	maxclick)
		{ return(*(int *)0); }

#undef _nc_has_mouse
NCURSES_BOOL _nc_has_mouse(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_mouse_sp
NCURSES_BOOL has_mouse_sp(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_mouse
NCURSES_BOOL has_mouse(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef wmouse_trafo
NCURSES_BOOL wmouse_trafo(
		const WINDOW *win, 
		int	*pY, 
		int	*pX, 
		NCURSES_BOOL to_screen)
		{ return(*(NCURSES_BOOL *)0); }

/* ./base/lib_move.c */

#undef wmove
int	wmove(
		WINDOW	*win, 
		int	y, 
		int	x)
		{ return(*(int *)0); }

/* ./tty/lib_mvcur.c */

#undef _nc_msec_cost_sp
int	_nc_msec_cost_sp(
		SCREEN	*sp, 
		const char *const cap, 
		int	affcnt)
		{ return(*(int *)0); }

#undef _nc_msec_cost
int	_nc_msec_cost(
		const char *const cap, 
		int	affcnt)
		{ return(*(int *)0); }

#undef _nc_mvcur_resume_sp
void	_nc_mvcur_resume_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_mvcur_resume
void	_nc_mvcur_resume(void)
		{ /* void */ }

#undef _nc_mvcur_init_sp
void	_nc_mvcur_init_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_mvcur_init
void	_nc_mvcur_init(void)
		{ /* void */ }

#undef _nc_mvcur_wrap_sp
void	_nc_mvcur_wrap_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_mvcur_wrap
void	_nc_mvcur_wrap(void)
		{ /* void */ }

#undef _nc_mvcur_sp
int	_nc_mvcur_sp(
		SCREEN	*sp, 
		int	yold, 
		int	xold, 
		int	ynew, 
		int	xnew)
		{ return(*(int *)0); }

#undef _nc_mvcur
int	_nc_mvcur(
		int	yold, 
		int	xold, 
		int	ynew, 
		int	xnew)
		{ return(*(int *)0); }

#undef mvcur_sp
int	mvcur_sp(
		SCREEN	*sp, 
		int	yold, 
		int	xold, 
		int	ynew, 
		int	xnew)
		{ return(*(int *)0); }

#undef mvcur
int	mvcur(
		int	yold, 
		int	xold, 
		int	ynew, 
		int	xnew)
		{ return(*(int *)0); }

#undef _nc_optimize_enable
int	_nc_optimize_enable;

/* ./base/lib_mvwin.c */

#undef mvwin
int	mvwin(
		WINDOW	*win, 
		int	by, 
		int	bx)
		{ return(*(int *)0); }

/* ./base/lib_newterm.c */

#undef filter_sp
void	filter_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef filter
void	filter(void)
		{ /* void */ }

#undef nofilter_sp
void	nofilter_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef nofilter
void	nofilter(void)
		{ /* void */ }

#undef newterm_sp
SCREEN	*newterm_sp(
		SCREEN	*sp, 
		const char *name, 
		FILE	*ofp, 
		FILE	*ifp)
		{ return(*(SCREEN **)0); }

#undef newterm
SCREEN	*newterm(
		const char *name, 
		FILE	*ofp, 
		FILE	*ifp)
		{ return(*(SCREEN **)0); }

/* ./base/lib_newwin.c */

#undef _nc_freewin
int	_nc_freewin(
		WINDOW	*win)
		{ return(*(int *)0); }

#undef newwin_sp
WINDOW	*newwin_sp(
		SCREEN	*sp, 
		int	num_lines, 
		int	num_columns, 
		int	begy, 
		int	begx)
		{ return(*(WINDOW **)0); }

#undef newwin
WINDOW	*newwin(
		int	num_lines, 
		int	num_columns, 
		int	begy, 
		int	begx)
		{ return(*(WINDOW **)0); }

#undef derwin
WINDOW	*derwin(
		WINDOW	*orig, 
		int	num_lines, 
		int	num_columns, 
		int	begy, 
		int	begx)
		{ return(*(WINDOW **)0); }

#undef subwin
WINDOW	*subwin(
		WINDOW	*w, 
		int	l, 
		int	c, 
		int	y, 
		int	x)
		{ return(*(WINDOW **)0); }

#undef _nc_makenew_sp
WINDOW	*_nc_makenew_sp(
		SCREEN	*sp, 
		int	num_lines, 
		int	num_columns, 
		int	begy, 
		int	begx, 
		int	flags)
		{ return(*(WINDOW **)0); }

#undef _nc_curscr_of
WINDOW	*_nc_curscr_of(
		SCREEN	*sp)
		{ return(*(WINDOW **)0); }

#undef _nc_newscr_of
WINDOW	*_nc_newscr_of(
		SCREEN	*sp)
		{ return(*(WINDOW **)0); }

#undef _nc_stdscr_of
WINDOW	*_nc_stdscr_of(
		SCREEN	*sp)
		{ return(*(WINDOW **)0); }

/* ./base/lib_nl.c */

#undef nl_sp
int	nl_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef nl
int	nl(void)
		{ return(*(int *)0); }

#undef nonl_sp
int	nonl_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef nonl
int	nonl(void)
		{ return(*(int *)0); }

/* ./base/lib_overlay.c */

#undef overlay
int	overlay(
		const WINDOW *win1, 
		WINDOW	*win2)
		{ return(*(int *)0); }

#undef overwrite
int	overwrite(
		const WINDOW *win1, 
		WINDOW	*win2)
		{ return(*(int *)0); }

#undef copywin
int	copywin(
		const WINDOW *src, 
		WINDOW	*dst, 
		int	sminrow, 
		int	smincol, 
		int	dminrow, 
		int	dmincol, 
		int	dmaxrow, 
		int	dmaxcol, 
		int	over)
		{ return(*(int *)0); }

/* ./base/lib_pad.c */

#undef newpad_sp
WINDOW	*newpad_sp(
		SCREEN	*sp, 
		int	l, 
		int	c)
		{ return(*(WINDOW **)0); }

#undef newpad
WINDOW	*newpad(
		int	l, 
		int	c)
		{ return(*(WINDOW **)0); }

#undef subpad
WINDOW	*subpad(
		WINDOW	*orig, 
		int	l, 
		int	c, 
		int	begy, 
		int	begx)
		{ return(*(WINDOW **)0); }

#undef prefresh
int	prefresh(
		WINDOW	*win, 
		int	pminrow, 
		int	pmincol, 
		int	sminrow, 
		int	smincol, 
		int	smaxrow, 
		int	smaxcol)
		{ return(*(int *)0); }

#undef pnoutrefresh
int	pnoutrefresh(
		WINDOW	*win, 
		int	pminrow, 
		int	pmincol, 
		int	sminrow, 
		int	smincol, 
		int	smaxrow, 
		int	smaxcol)
		{ return(*(int *)0); }

#undef pechochar
int	pechochar(
		WINDOW	*pad, 
		const chtype ch)
		{ return(*(int *)0); }

/* ./base/lib_printw.c */

#undef printw
int	printw(
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef wprintw
int	wprintw(
		WINDOW	*win, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef mvprintw
int	mvprintw(
		int	y, 
		int	x, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef mvwprintw
int	mvwprintw(
		WINDOW	*win, 
		int	y, 
		int	x, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef vwprintw
int	vwprintw(
		WINDOW	*win, 
		const char *fmt, 
		va_list	argp)
		{ return(*(int *)0); }

/* ./base/lib_redrawln.c */

#undef wredrawln
int	wredrawln(
		WINDOW	*win, 
		int	beg, 
		int	num)
		{ return(*(int *)0); }

/* ./base/lib_refresh.c */

#undef wrefresh
int	wrefresh(
		WINDOW	*win)
		{ return(*(int *)0); }

#undef wnoutrefresh
int	wnoutrefresh(
		WINDOW	*win)
		{ return(*(int *)0); }

/* ./base/lib_restart.c */

#undef restartterm_sp
int	restartterm_sp(
		SCREEN	*sp, 
		const char *termp, 
		int	filenum, 
		int	*errret)
		{ return(*(int *)0); }

#undef restartterm
int	restartterm(
		const char *termp, 
		int	filenum, 
		int	*errret)
		{ return(*(int *)0); }

/* ./base/lib_scanw.c */

#undef vwscanw
int	vwscanw(
		WINDOW	*win, 
		const char *fmt, 
		va_list	argp)
		{ return(*(int *)0); }

#undef scanw
int	scanw(
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef wscanw
int	wscanw(
		WINDOW	*win, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef mvscanw
int	mvscanw(
		int	y, 
		int	x, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

#undef mvwscanw
int	mvwscanw(
		WINDOW	*win, 
		int	y, 
		int	x, 
		const char *fmt, 
		...)
		{ return(*(int *)0); }

/* ./base/lib_screen.c */

#undef getwin_sp
WINDOW	*getwin_sp(
		SCREEN	*sp, 
		FILE	*filep)
		{ return(*(WINDOW **)0); }

#undef getwin
WINDOW	*getwin(
		FILE	*filep)
		{ return(*(WINDOW **)0); }

#undef putwin
int	putwin(
		WINDOW	*win, 
		FILE	*filep)
		{ return(*(int *)0); }

#undef scr_restore_sp
int	scr_restore_sp(
		SCREEN	*sp, 
		const char *file)
		{ return(*(int *)0); }

#undef scr_restore
int	scr_restore(
		const char *file)
		{ return(*(int *)0); }

#undef scr_dump
int	scr_dump(
		const char *file)
		{ return(*(int *)0); }

#undef scr_init_sp
int	scr_init_sp(
		SCREEN	*sp, 
		const char *file)
		{ return(*(int *)0); }

#undef scr_init
int	scr_init(
		const char *file)
		{ return(*(int *)0); }

#undef scr_set_sp
int	scr_set_sp(
		SCREEN	*sp, 
		const char *file)
		{ return(*(int *)0); }

#undef scr_set
int	scr_set(
		const char *file)
		{ return(*(int *)0); }

/* ./base/lib_scroll.c */

#undef _nc_scroll_window
void	_nc_scroll_window(
		WINDOW	*win, 
		int const n, 
		int const top, 
		int const bottom, 
		chtype	blank)
		{ /* void */ }

#undef wscrl
int	wscrl(
		WINDOW	*win, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_scrollok.c */

#undef scrollok
int	scrollok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/lib_scrreg.c */

#undef wsetscrreg
int	wsetscrreg(
		WINDOW	*win, 
		int	top, 
		int	bottom)
		{ return(*(int *)0); }

/* ./base/lib_set_term.c */

#undef set_term
SCREEN	*set_term(
		SCREEN	*screenp)
		{ return(*(SCREEN **)0); }

#undef delscreen
void	delscreen(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_setupscreen_sp
int	_nc_setupscreen_sp(
		SCREEN	**spp, 
		int	slines, 
		int	scolumns, 
		FILE	*output, 
		int	filtered, 
		int	slk_format)
		{ return(*(int *)0); }

#undef _nc_setupscreen
int	_nc_setupscreen(
		int	slines, 
		int	scolumns, 
		FILE	*output, 
		int	filtered, 
		int	slk_format)
		{ return(*(int *)0); }

#undef _nc_ripoffline_sp
int	_nc_ripoffline_sp(
		SCREEN	*sp, 
		int	line, 
		int	(*init)(
		WINDOW	*p1, 
		int	p2))
		{ return(*(int *)0); }

#undef _nc_ripoffline
int	_nc_ripoffline(
		int	line, 
		int	(*init)(
		WINDOW	*p1, 
		int	p2))
		{ return(*(int *)0); }

#undef ripoffline_sp
int	ripoffline_sp(
		SCREEN	*sp, 
		int	line, 
		int	(*init)(
		WINDOW	*p1, 
		int	p2))
		{ return(*(int *)0); }

#undef ripoffline
int	ripoffline(
		int	line, 
		int	(*init)(
		WINDOW	*p1, 
		int	p2))
		{ return(*(int *)0); }

/* ./base/lib_slk.c */

#undef _nc_format_slks
int	_nc_format_slks(
		SCREEN	*sp, 
		int	cols)
		{ return(*(int *)0); }

#undef _nc_slk_initialize
int	_nc_slk_initialize(
		WINDOW	*stwin, 
		int	cols)
		{ return(*(int *)0); }

#undef slk_restore_sp
int	slk_restore_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef slk_restore
int	slk_restore(void)
		{ return(*(int *)0); }

/* ./base/lib_slkatr_set.c */

#undef slk_attr_set_sp
int	slk_attr_set_sp(
		SCREEN	*sp, 
		const attr_t attr, 
		short	color_pair_number, 
		void	*opts)
		{ return(*(int *)0); }

#undef slk_attr_set
int	slk_attr_set(
		const attr_t attr, 
		short	color_pair_number, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_slkatrof.c */

#undef slk_attroff_sp
int	slk_attroff_sp(
		SCREEN	*sp, 
		const chtype attr)
		{ return(*(int *)0); }

#undef slk_attroff
int	slk_attroff(
		const chtype attr)
		{ return(*(int *)0); }

/* ./base/lib_slkatron.c */

#undef slk_attron_sp
int	slk_attron_sp(
		SCREEN	*sp, 
		const chtype attr)
		{ return(*(int *)0); }

#undef slk_attron
int	slk_attron(
		const chtype attr)
		{ return(*(int *)0); }

/* ./base/lib_slkatrset.c */

#undef slk_attrset_sp
int	slk_attrset_sp(
		SCREEN	*sp, 
		const chtype attr)
		{ return(*(int *)0); }

#undef slk_attrset
int	slk_attrset(
		const chtype attr)
		{ return(*(int *)0); }

/* ./base/lib_slkattr.c */

#undef slk_attr_sp
attr_t	slk_attr_sp(
		SCREEN	*sp)
		{ return(*(attr_t *)0); }

#undef slk_attr
attr_t	slk_attr(void)
		{ return(*(attr_t *)0); }

/* ./base/lib_slkclear.c */

#undef slk_clear_sp
int	slk_clear_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef slk_clear
int	slk_clear(void)
		{ return(*(int *)0); }

/* ./base/lib_slkcolor.c */

#undef slk_color_sp
int	slk_color_sp(
		SCREEN	*sp, 
		short	color_pair_number)
		{ return(*(int *)0); }

#undef slk_color
int	slk_color(
		short	color_pair_number)
		{ return(*(int *)0); }

/* ./base/lib_slkinit.c */

#undef slk_init_sp
int	slk_init_sp(
		SCREEN	*sp, 
		int	format)
		{ return(*(int *)0); }

#undef slk_init
int	slk_init(
		int	format)
		{ return(*(int *)0); }

/* ./base/lib_slklab.c */

#undef slk_label_sp
char	*slk_label_sp(
		SCREEN	*sp, 
		int	n)
		{ return(*(char **)0); }

#undef slk_label
char	*slk_label(
		int	n)
		{ return(*(char **)0); }

/* ./base/lib_slkrefr.c */

#undef slk_noutrefresh_sp
int	slk_noutrefresh_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef slk_noutrefresh
int	slk_noutrefresh(void)
		{ return(*(int *)0); }

#undef slk_refresh_sp
int	slk_refresh_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef slk_refresh
int	slk_refresh(void)
		{ return(*(int *)0); }

/* ./base/lib_slkset.c */

#undef slk_set_sp
int	slk_set_sp(
		SCREEN	*sp, 
		int	i, 
		const char *astr, 
		int	format)
		{ return(*(int *)0); }

#undef slk_set
int	slk_set(
		int	i, 
		const char *astr, 
		int	format)
		{ return(*(int *)0); }

/* ./base/lib_slktouch.c */

#undef slk_touch_sp
int	slk_touch_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef slk_touch
int	slk_touch(void)
		{ return(*(int *)0); }

/* ./base/lib_touch.c */

#undef is_linetouched
NCURSES_BOOL is_linetouched(
		WINDOW	*win, 
		int	line)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_wintouched
NCURSES_BOOL is_wintouched(
		WINDOW	*win)
		{ return(*(NCURSES_BOOL *)0); }

#undef wtouchln
int	wtouchln(
		WINDOW	*win, 
		int	y, 
		int	n, 
		int	changed)
		{ return(*(int *)0); }

/* ./trace/lib_tracedmp.c */

#undef _tracedump
void	_tracedump(
		const char *name, 
		WINDOW	*win)
		{ /* void */ }

/* ./trace/lib_tracemse.c */

#undef _nc_trace_mmask_t
char	*_nc_trace_mmask_t(
		SCREEN	*sp, 
		mmask_t	code)
		{ return(*(char **)0); }

#undef _nc_tracemouse
char	*_nc_tracemouse(
		SCREEN	*sp, 
		MEVENT const *ep)
		{ return(*(char **)0); }

#undef _nc_retrace_mmask_t
mmask_t	_nc_retrace_mmask_t(
		SCREEN	*sp, 
		mmask_t	code)
		{ return(*(mmask_t *)0); }

#undef _tracemouse
char	*_tracemouse(
		MEVENT const *ep)
		{ return(*(char **)0); }

/* ./tty/lib_tstp.c */

#undef _nc_signal_handler
void	_nc_signal_handler(
		int	enable)
		{ /* void */ }

/* ./base/lib_ungetch.c */

#undef _nc_fifo_dump
void	_nc_fifo_dump(
		SCREEN	*sp)
		{ /* void */ }

#undef ungetch_sp
int	ungetch_sp(
		SCREEN	*sp, 
		int	ch)
		{ return(*(int *)0); }

#undef ungetch
int	ungetch(
		int	ch)
		{ return(*(int *)0); }

/* ./tty/lib_vidattr.c */

#undef vidputs_sp
int	vidputs_sp(
		SCREEN	*sp, 
		chtype	newmode, 
		NCURSES_OUTC_sp outc)
		{ return(*(int *)0); }

#undef vidputs
int	vidputs(
		chtype	newmode, 
		NCURSES_OUTC outc)
		{ return(*(int *)0); }

#undef vidattr_sp
int	vidattr_sp(
		SCREEN	*sp, 
		chtype	newmode)
		{ return(*(int *)0); }

#undef vidattr
int	vidattr(
		chtype	newmode)
		{ return(*(int *)0); }

#undef termattrs_sp
chtype	termattrs_sp(
		SCREEN	*sp)
		{ return(*(chtype *)0); }

#undef termattrs
chtype	termattrs(void)
		{ return(*(chtype *)0); }

/* ./base/lib_vline.c */

#undef wvline
int	wvline(
		WINDOW	*win, 
		chtype	ch, 
		int	n)
		{ return(*(int *)0); }

/* ./base/lib_wattroff.c */

#undef wattr_off
int	wattr_off(
		WINDOW	*win, 
		attr_t	at, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_wattron.c */

#undef wattr_on
int	wattr_on(
		WINDOW	*win, 
		attr_t	at, 
		void	*opts)
		{ return(*(int *)0); }

/* ./base/lib_winch.c */

#undef winch
chtype	winch(
		WINDOW	*win)
		{ return(*(chtype *)0); }

/* ./base/lib_window.c */

#undef _nc_synchook
void	_nc_synchook(
		WINDOW	*win)
		{ /* void */ }

#undef mvderwin
int	mvderwin(
		WINDOW	*win, 
		int	y, 
		int	x)
		{ return(*(int *)0); }

#undef syncok
int	syncok(
		WINDOW	*win, 
		NCURSES_BOOL bf)
		{ return(*(int *)0); }

#undef wsyncup
void	wsyncup(
		WINDOW	*win)
		{ /* void */ }

#undef wsyncdown
void	wsyncdown(
		WINDOW	*win)
		{ /* void */ }

#undef wcursyncup
void	wcursyncup(
		WINDOW	*win)
		{ /* void */ }

#undef dupwin
WINDOW	*dupwin(
		WINDOW	*win)
		{ return(*(WINDOW **)0); }

/* ./base/nc_panel.c */

#undef _nc_panelhook_sp
struct panelhook *_nc_panelhook_sp(
		SCREEN	*sp)
		{ return(*(struct panelhook **)0); }

#undef _nc_panelhook
struct panelhook *_nc_panelhook(void)
		{ return(*(struct panelhook **)0); }

/* ./base/safe_sprintf.c */

#undef _nc_printf_string_sp
char	*_nc_printf_string_sp(
		SCREEN	*sp, 
		const char *fmt, 
		va_list	ap)
		{ return(*(char **)0); }

#undef _nc_printf_string
char	*_nc_printf_string(
		const char *fmt, 
		va_list	ap)
		{ return(*(char **)0); }

/* ./tty/tty_update.c */

#undef doupdate_sp
int	doupdate_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef doupdate
int	doupdate(void)
		{ return(*(int *)0); }

#undef _nc_scrolln_sp
int	_nc_scrolln_sp(
		SCREEN	*sp, 
		int	n, 
		int	top, 
		int	bot, 
		int	maxy)
		{ return(*(int *)0); }

#undef _nc_scrolln
int	_nc_scrolln(
		int	n, 
		int	top, 
		int	bot, 
		int	maxy)
		{ return(*(int *)0); }

#undef _nc_screen_resume_sp
void	_nc_screen_resume_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_screen_resume
void	_nc_screen_resume(void)
		{ /* void */ }

#undef _nc_screen_init_sp
void	_nc_screen_init_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_screen_init
void	_nc_screen_init(void)
		{ /* void */ }

#undef _nc_screen_wrap_sp
void	_nc_screen_wrap_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_screen_wrap
void	_nc_screen_wrap(void)
		{ /* void */ }

#undef _nc_do_xmc_glitch_sp
void	_nc_do_xmc_glitch_sp(
		SCREEN	*sp, 
		attr_t	previous)
		{ /* void */ }

#undef _nc_do_xmc_glitch
void	_nc_do_xmc_glitch(
		attr_t	previous)
		{ /* void */ }

/* ./trace/varargs.c */

typedef enum {
    atUnknown = 0, atInteger, atFloat, atPoint, atString
} ARGTYPE;

#undef _nc_varargs
char	*_nc_varargs(
		const char *fmt, 
		va_list	ap)
		{ return(*(char **)0); }

/* ./base/vsscanf.c */

#undef _nc_vsscanf
void	_nc_vsscanf(void)
		{ /* void */ }

/* ./base/lib_freeall.c */

#undef _nc_freeall
void	_nc_freeall(void)
		{ /* void */ }

#undef _nc_free_and_exit_sp
void	_nc_free_and_exit_sp(
		SCREEN	*sp, 
		int	code)
		{ /* void */ }

#undef _nc_free_and_exit
void	_nc_free_and_exit(
		int	code)
		{ /* void */ }

/* ./expanded.c */

#undef _nc_toggle_attr_on
void	_nc_toggle_attr_on(
		attr_t	*S, 
		attr_t	at)
		{ /* void */ }

#undef _nc_toggle_attr_off
void	_nc_toggle_attr_off(
		attr_t	*S, 
		attr_t	at)
		{ /* void */ }

#undef _nc_DelCharCost_sp
int	_nc_DelCharCost_sp(
		SCREEN	*sp, 
		int	count)
		{ return(*(int *)0); }

#undef _nc_InsCharCost_sp
int	_nc_InsCharCost_sp(
		SCREEN	*sp, 
		int	count)
		{ return(*(int *)0); }

#undef _nc_UpdateAttrs_sp
void	_nc_UpdateAttrs_sp(
		SCREEN	*sp, 
		chtype	c)
		{ /* void */ }

#undef _nc_DelCharCost
int	_nc_DelCharCost(
		int	count)
		{ return(*(int *)0); }

#undef _nc_InsCharCost
int	_nc_InsCharCost(
		int	count)
		{ return(*(int *)0); }

#undef _nc_UpdateAttrs
void	_nc_UpdateAttrs(
		chtype	c)
		{ /* void */ }

/* ./base/legacy_coding.c */

#undef use_legacy_coding_sp
int	use_legacy_coding_sp(
		SCREEN	*sp, 
		int	level)
		{ return(*(int *)0); }

#undef use_legacy_coding
int	use_legacy_coding(
		int	level)
		{ return(*(int *)0); }

/* ./base/lib_dft_fgbg.c */

#undef use_default_colors_sp
int	use_default_colors_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef use_default_colors
int	use_default_colors(void)
		{ return(*(int *)0); }

#undef assume_default_colors_sp
int	assume_default_colors_sp(
		SCREEN	*sp, 
		int	fg, 
		int	bg)
		{ return(*(int *)0); }

#undef assume_default_colors
int	assume_default_colors(
		int	fg, 
		int	bg)
		{ return(*(int *)0); }

/* ./tinfo/lib_print.c */

#undef mcprint_sp
int	mcprint_sp(
		SCREEN	*sp, 
		char	*data, 
		int	len)
		{ return(*(int *)0); }

#undef mcprint
int	mcprint(
		char	*data, 
		int	len)
		{ return(*(int *)0); }

/* ./base/resizeterm.c */

#undef is_term_resized_sp
NCURSES_BOOL is_term_resized_sp(
		SCREEN	*sp, 
		int	ToLines, 
		int	ToCols)
		{ return(*(NCURSES_BOOL *)0); }

#undef is_term_resized
NCURSES_BOOL is_term_resized(
		int	ToLines, 
		int	ToCols)
		{ return(*(NCURSES_BOOL *)0); }

#undef resize_term_sp
int	resize_term_sp(
		SCREEN	*sp, 
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

#undef resize_term
int	resize_term(
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

#undef resizeterm_sp
int	resizeterm_sp(
		SCREEN	*sp, 
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

#undef resizeterm
int	resizeterm(
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

/* ./trace/trace_xnames.c */

#undef _nc_trace_xnames
void	_nc_trace_xnames(
		TERMTYPE *tp)
		{ /* void */ }

/* ./tinfo/use_screen.c */

#undef use_screen
int	use_screen(
		SCREEN	*screen, 
		NCURSES_SCREEN_CB func, 
		void	*data)
		{ return(*(int *)0); }

/* ./base/use_window.c */

#undef use_window
int	use_window(
		WINDOW	*win, 
		NCURSES_WINDOW_CB func, 
		void	*data)
		{ return(*(int *)0); }

/* ./base/wresize.c */

#undef wresize
int	wresize(
		WINDOW	*win, 
		int	ToLines, 
		int	ToCols)
		{ return(*(int *)0); }

/* ./tinfo/access.c */

#undef _nc_rootname
char	*_nc_rootname(
		char	*path)
		{ return(*(char **)0); }

#undef _nc_is_abs_path
NCURSES_BOOL _nc_is_abs_path(
		const char *path)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_pathlast
unsigned _nc_pathlast(
		const char *path)
		{ return(*(unsigned *)0); }

#undef _nc_basename
char	*_nc_basename(
		char	*path)
		{ return(*(char **)0); }

#undef _nc_access
int	_nc_access(
		const char *path, 
		int	mode)
		{ return(*(int *)0); }

#undef _nc_is_dir_path
NCURSES_BOOL _nc_is_dir_path(
		const char *path)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_is_file_path
NCURSES_BOOL _nc_is_file_path(
		const char *path)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_env_access
int	_nc_env_access(void)
		{ return(*(int *)0); }

/* ./tinfo/add_tries.c */

#undef _nc_add_to_try
int	_nc_add_to_try(
		TRIES	**tree, 
		const char *str, 
		unsigned code)
		{ return(*(int *)0); }

/* ./tinfo/alloc_ttype.c */

#undef _nc_align_termtype
void	_nc_align_termtype(
		TERMTYPE *to, 
		TERMTYPE *from)
		{ /* void */ }

#undef _nc_copy_termtype
void	_nc_copy_termtype(
		TERMTYPE *dst, 
		const TERMTYPE *src)
		{ /* void */ }

/* ./codes.c */

#undef _nc_boolcodes
const char *const *_nc_boolcodes(void)
		{ return(*(const char **)0); }

#undef _nc_numcodes
const char *const *_nc_numcodes(void)
		{ return(*(const char **)0); }

#undef _nc_strcodes
const char *const *_nc_strcodes(void)
		{ return(*(const char **)0); }

/* ./comp_captab.c */

#undef _nc_get_table
const struct name_table_entry *_nc_get_table(
		NCURSES_BOOL termcap)
		{ return(*(const struct name_table_entry **)0); }

#undef _nc_get_hash_table
const HashValue *_nc_get_hash_table(
		NCURSES_BOOL termcap)
		{ return(*(const HashValue **)0); }

#undef _nc_get_alias_table
const struct alias *_nc_get_alias_table(
		NCURSES_BOOL termcap)
		{ return(*(const struct alias **)0); }

#undef _nc_get_hash_info
const HashData *_nc_get_hash_info(
		NCURSES_BOOL termcap)
		{ return(*(const HashData **)0); }

/* ./tinfo/comp_error.c */

#undef _nc_suppress_warnings
NCURSES_BOOL _nc_suppress_warnings;
#undef _nc_curr_line
int	_nc_curr_line;
#undef _nc_curr_col
int	_nc_curr_col;

#undef _nc_get_source
const char *_nc_get_source(void)
		{ return(*(const char **)0); }

#undef _nc_set_source
void	_nc_set_source(
		const char *const name)
		{ /* void */ }

#undef _nc_set_type
void	_nc_set_type(
		const char *const name)
		{ /* void */ }

#undef _nc_get_type
void	_nc_get_type(
		char	*name)
		{ /* void */ }

#undef _nc_warning
void	_nc_warning(
		const char *const fmt, 
		...)
		{ /* void */ }

#undef _nc_err_abort
void	_nc_err_abort(
		const char *const fmt, 
		...)
		{ /* void */ }

#undef _nc_syserr_abort
void	_nc_syserr_abort(
		const char *const fmt, 
		...)
		{ /* void */ }

/* ./tinfo/comp_hash.c */

#undef _nc_find_entry
struct name_table_entry const *_nc_find_entry(
		const char *string, 
		const HashValue *hash_table)
		{ return(*(struct name_table_entry const **)0); }

#undef _nc_find_type_entry
struct name_table_entry const *_nc_find_type_entry(
		const char *string, 
		int	type, 
		NCURSES_BOOL termcap)
		{ return(*(struct name_table_entry const **)0); }

/* ./tinfo/db_iterator.c */

#undef _nc_tic_dir
const char *_nc_tic_dir(
		const char *path)
		{ return(*(const char **)0); }

#undef _nc_keep_tic_dir
void	_nc_keep_tic_dir(
		const char *path)
		{ /* void */ }

#undef _nc_last_db
void	_nc_last_db(void)
		{ /* void */ }

#undef _nc_next_db
const char *_nc_next_db(
		DBDIRS	*state, 
		int	*offset)
		{ return(*(const char **)0); }

#undef _nc_first_db
void	_nc_first_db(
		DBDIRS	*state, 
		int	*offset)
		{ /* void */ }

/* ./tinfo/doalloc.c */

#undef _nc_doalloc
void	*_nc_doalloc(
		void	*oldp, 
		size_t	amount)
		{ return(*(void **)0); }

/* ./tinfo/entries.c */

#undef _nc_head
ENTRY	*_nc_head;
#undef _nc_tail
ENTRY	*_nc_tail;

#undef _nc_free_entry
void	_nc_free_entry(
		ENTRY	*headp, 
		TERMTYPE *tterm)
		{ /* void */ }

#undef _nc_free_entries
void	_nc_free_entries(
		ENTRY	*headp)
		{ /* void */ }

#undef _nc_delink_entry
ENTRY	*_nc_delink_entry(
		ENTRY	*headp, 
		TERMTYPE *tterm)
		{ return(*(ENTRY **)0); }

#undef _nc_leaks_tinfo
void	_nc_leaks_tinfo(void)
		{ /* void */ }

/* ./fallback.c */

#undef _nc_fallback
const TERMTYPE *_nc_fallback(
		const char *name)
		{ return(*(const TERMTYPE **)0); }

/* ./tinfo/free_ttype.c */

#undef _nc_free_termtype
void	_nc_free_termtype(
		TERMTYPE *ptr)
		{ /* void */ }

#undef _nc_user_definable
NCURSES_BOOL _nc_user_definable;

#undef use_extended_names
int	use_extended_names(
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./tinfo/getenv_num.c */

#undef _nc_getenv_num
int	_nc_getenv_num(
		const char *name)
		{ return(*(int *)0); }

#undef _nc_setenv_num
void	_nc_setenv_num(
		const char *name, 
		int	value)
		{ /* void */ }

/* ./tinfo/home_terminfo.c */

#undef _nc_home_terminfo
char	*_nc_home_terminfo(void)
		{ return(*(char **)0); }

/* ./tinfo/init_keytry.c */

#undef _nc_init_keytry
void	_nc_init_keytry(
		SCREEN	*sp)
		{ /* void */ }

/* ./tinfo/lib_acs.c */

#undef _nc_acs_map
chtype	*_nc_acs_map(void)
		{ return(*(chtype **)0); }

#undef _nc_init_acs_sp
void	_nc_init_acs_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_init_acs
void	_nc_init_acs(void)
		{ /* void */ }

/* ./tinfo/lib_baudrate.c */

struct speed {
    short s; 
    int sp; 
};

#undef _nc_baudrate
int	_nc_baudrate(
		int	OSpeed)
		{ return(*(int *)0); }

#undef _nc_ospeed
int	_nc_ospeed(
		int	BaudRate)
		{ return(*(int *)0); }

#undef baudrate_sp
int	baudrate_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef baudrate
int	baudrate(void)
		{ return(*(int *)0); }

/* ./tinfo/lib_cur_term.c */

#undef _nc_get_cur_term_sp
TERMINAL *_nc_get_cur_term_sp(
		SCREEN	*sp)
		{ return(*(TERMINAL **)0); }

#undef _nc_get_cur_term
TERMINAL *_nc_get_cur_term(void)
		{ return(*(TERMINAL **)0); }

#undef _nc_cur_term
TERMINAL *_nc_cur_term(void)
		{ return(*(TERMINAL **)0); }

#undef set_curterm_sp
TERMINAL *set_curterm_sp(
		SCREEN	*sp, 
		TERMINAL *termp)
		{ return(*(TERMINAL **)0); }

#undef set_curterm
TERMINAL *set_curterm(
		TERMINAL *termp)
		{ return(*(TERMINAL **)0); }

#undef del_curterm_sp
int	del_curterm_sp(
		SCREEN	*sp, 
		TERMINAL *termp)
		{ return(*(int *)0); }

#undef del_curterm
int	del_curterm(
		TERMINAL *termp)
		{ return(*(int *)0); }

/* ./tinfo/lib_data.c */

#undef _nc_stdscr
WINDOW	*_nc_stdscr(void)
		{ return(*(WINDOW **)0); }

#undef _nc_curscr
WINDOW	*_nc_curscr(void)
		{ return(*(WINDOW **)0); }

#undef _nc_newscr
WINDOW	*_nc_newscr(void)
		{ return(*(WINDOW **)0); }

#undef _nc_screen_chain
SCREEN	*_nc_screen_chain;
#undef SP
SCREEN	*SP;
#undef _nc_globals
NCURSES_GLOBALS _nc_globals;
#undef _nc_prescreen
NCURSES_PRESCREEN _nc_prescreen;

#undef _nc_screen_of
SCREEN	*_nc_screen_of(
		WINDOW	*win)
		{ return(*(SCREEN **)0); }

#undef _nc_init_pthreads
void	_nc_init_pthreads(void)
		{ /* void */ }

#undef _nc_mutex_init
void	_nc_mutex_init(
		pthread_mutex_t *obj)
		{ /* void */ }

#undef _nc_mutex_lock
int	_nc_mutex_lock(
		pthread_mutex_t *obj)
		{ return(*(int *)0); }

#undef _nc_mutex_trylock
int	_nc_mutex_trylock(
		pthread_mutex_t *obj)
		{ return(*(int *)0); }

#undef _nc_mutex_unlock
int	_nc_mutex_unlock(
		pthread_mutex_t *obj)
		{ return(*(int *)0); }

/* ./tinfo/lib_has_cap.c */

#undef has_ic_sp
NCURSES_BOOL has_ic_sp(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_ic
NCURSES_BOOL has_ic(void)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_il_sp
NCURSES_BOOL has_il_sp(
		SCREEN	*sp)
		{ return(*(NCURSES_BOOL *)0); }

#undef has_il
NCURSES_BOOL has_il(void)
		{ return(*(NCURSES_BOOL *)0); }

/* ./tinfo/lib_kernel.c */

#undef erasechar_sp
char	erasechar_sp(
		SCREEN	*sp)
		{ return(*(char *)0); }

#undef erasechar
char	erasechar(void)
		{ return(*(char *)0); }

#undef killchar_sp
char	killchar_sp(
		SCREEN	*sp)
		{ return(*(char *)0); }

#undef killchar
char	killchar(void)
		{ return(*(char *)0); }

#undef flushinp_sp
int	flushinp_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef flushinp
int	flushinp(void)
		{ return(*(int *)0); }

/* ./lib_keyname.c */

struct kn { short offset; int code; };

#undef keyname_sp
const char *keyname_sp(
		SCREEN	*sp, 
		int	c)
		{ return(*(const char **)0); }

#undef keyname
const char *keyname(
		int	c)
		{ return(*(const char **)0); }

/* ./tinfo/lib_longname.c */

#undef longname_sp
char	*longname_sp(
		SCREEN	*sp)
		{ return(*(char **)0); }

#undef longname
char	*longname(void)
		{ return(*(char **)0); }

/* ./tinfo/lib_napms.c */

#undef napms_sp
int	napms_sp(
		SCREEN	*sp, 
		int	ms)
		{ return(*(int *)0); }

#undef napms
int	napms(
		int	ms)
		{ return(*(int *)0); }

/* ./tinfo/lib_options.c */

#undef idlok
int	idlok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef idcok
void	idcok(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ /* void */ }

#undef halfdelay_sp
int	halfdelay_sp(
		SCREEN	*sp, 
		int	t)
		{ return(*(int *)0); }

#undef halfdelay
int	halfdelay(
		int	t)
		{ return(*(int *)0); }

#undef nodelay
int	nodelay(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef notimeout
int	notimeout(
		WINDOW	*win, 
		NCURSES_BOOL f)
		{ return(*(int *)0); }

#undef wtimeout
void	wtimeout(
		WINDOW	*win, 
		int	delay)
		{ /* void */ }

#undef keypad
int	keypad(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef meta
int	meta(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef curs_set_sp
int	curs_set_sp(
		SCREEN	*sp, 
		int	vis)
		{ return(*(int *)0); }

#undef curs_set
int	curs_set(
		int	vis)
		{ return(*(int *)0); }

#undef typeahead_sp
int	typeahead_sp(
		SCREEN	*sp, 
		int	fd)
		{ return(*(int *)0); }

#undef typeahead
int	typeahead(
		int	fd)
		{ return(*(int *)0); }

#undef has_key_sp
int	has_key_sp(
		SCREEN	*sp, 
		int	keycode)
		{ return(*(int *)0); }

#undef has_key
int	has_key(
		int	keycode)
		{ return(*(int *)0); }

#undef _nc_putp_flush_sp
int	_nc_putp_flush_sp(
		SCREEN	*sp, 
		const char *name, 
		const char *value)
		{ return(*(int *)0); }

#undef _nc_keypad
int	_nc_keypad(
		SCREEN	*sp, 
		int	flag)
		{ return(*(int *)0); }

/* ./tinfo/lib_raw.c */

#undef raw_sp
int	raw_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef raw
int	raw(void)
		{ return(*(int *)0); }

#undef cbreak_sp
int	cbreak_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef cbreak
int	cbreak(void)
		{ return(*(int *)0); }

#undef qiflush_sp
void	qiflush_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef qiflush
void	qiflush(void)
		{ /* void */ }

#undef noraw_sp
int	noraw_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef noraw
int	noraw(void)
		{ return(*(int *)0); }

#undef nocbreak_sp
int	nocbreak_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef nocbreak
int	nocbreak(void)
		{ return(*(int *)0); }

#undef noqiflush_sp
void	noqiflush_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef noqiflush
void	noqiflush(void)
		{ /* void */ }

#undef intrflush_sp
int	intrflush_sp(
		SCREEN	*sp, 
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef intrflush
int	intrflush(
		WINDOW	*win, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./tinfo/lib_setup.c */

#undef _nc_ttytype
char	*_nc_ttytype(void)
		{ return(*(char **)0); }

#undef _nc_ptr_Lines
int	*_nc_ptr_Lines(
		SCREEN	*sp)
		{ return(*(int **)0); }

#undef _nc_LINES
int	_nc_LINES(void)
		{ return(*(int *)0); }

#undef _nc_ptr_Cols
int	*_nc_ptr_Cols(
		SCREEN	*sp)
		{ return(*(int **)0); }

#undef _nc_COLS
int	_nc_COLS(void)
		{ return(*(int *)0); }

#undef _nc_ptr_Tabsize
int	*_nc_ptr_Tabsize(
		SCREEN	*sp)
		{ return(*(int **)0); }

#undef _nc_TABSIZE
int	_nc_TABSIZE(void)
		{ return(*(int *)0); }

#undef set_tabsize_sp
int	set_tabsize_sp(
		SCREEN	*sp, 
		int	value)
		{ return(*(int *)0); }

#undef set_tabsize
int	set_tabsize(
		int	value)
		{ return(*(int *)0); }

#undef _nc_handle_sigwinch
int	_nc_handle_sigwinch(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef use_env_sp
void	use_env_sp(
		SCREEN	*sp, 
		NCURSES_BOOL f)
		{ /* void */ }

#undef use_tioctl_sp
void	use_tioctl_sp(
		SCREEN	*sp, 
		NCURSES_BOOL f)
		{ /* void */ }

#undef use_env
void	use_env(
		NCURSES_BOOL f)
		{ /* void */ }

#undef use_tioctl
void	use_tioctl(
		NCURSES_BOOL f)
		{ /* void */ }

#undef _nc_get_screensize
void	_nc_get_screensize(
		SCREEN	*sp, 
		int	*linep, 
		int	*colp)
		{ /* void */ }

#undef _nc_update_screensize
void	_nc_update_screensize(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_setup_tinfo
int	_nc_setup_tinfo(
		const char *const tn, 
		TERMTYPE *const tp)
		{ return(*(int *)0); }

#undef _nc_tinfo_cmdch
void	_nc_tinfo_cmdch(
		TERMINAL *termp, 
		int	proto)
		{ /* void */ }

#undef _nc_get_locale
char	*_nc_get_locale(void)
		{ return(*(char **)0); }

#undef _nc_unicode_locale
int	_nc_unicode_locale(void)
		{ return(*(int *)0); }

#undef _nc_locale_breaks_acs
int	_nc_locale_breaks_acs(
		TERMINAL *termp)
		{ return(*(int *)0); }

#undef _nc_setupterm
int	_nc_setupterm(
		const char *tname, 
		int	Filedes, 
		int	*errret, 
		int	reuse)
		{ return(*(int *)0); }

#undef new_prescr
SCREEN	*new_prescr(void)
		{ return(*(SCREEN **)0); }

#undef setupterm
int	setupterm(
		const char *tname, 
		int	Filedes, 
		int	*errret)
		{ return(*(int *)0); }

/* ./tinfo/lib_termcap.c */

#undef UP
char	*UP;
#undef BC
char	*BC;

#undef tgetent_sp
int	tgetent_sp(
		SCREEN	*sp, 
		char	*bufp, 
		const char *name)
		{ return(*(int *)0); }

#undef tgetent
int	tgetent(
		char	*bufp, 
		const char *name)
		{ return(*(int *)0); }

#undef tgetflag_sp
int	tgetflag_sp(
		SCREEN	*sp, 
		const char *id)
		{ return(*(int *)0); }

#undef tgetflag
int	tgetflag(
		const char *id)
		{ return(*(int *)0); }

#undef tgetnum_sp
int	tgetnum_sp(
		SCREEN	*sp, 
		const char *id)
		{ return(*(int *)0); }

#undef tgetnum
int	tgetnum(
		const char *id)
		{ return(*(int *)0); }

#undef tgetstr_sp
char	*tgetstr_sp(
		SCREEN	*sp, 
		const char *id, 
		char	**area)
		{ return(*(char **)0); }

#undef tgetstr
char	*tgetstr(
		const char *id, 
		char	**area)
		{ return(*(char **)0); }

/* ./tinfo/lib_termname.c */

#undef termname_sp
char	*termname_sp(
		SCREEN	*sp)
		{ return(*(char **)0); }

#undef termname
char	*termname(void)
		{ return(*(char **)0); }

/* ./tinfo/lib_tgoto.c */

#undef tgoto
char	*tgoto(
		const char *string, 
		int	x, 
		int	y)
		{ return(*(char **)0); }

/* ./tinfo/lib_ti.c */

#undef tigetflag_sp
int	tigetflag_sp(
		SCREEN	*sp, 
		const char *str)
		{ return(*(int *)0); }

#undef tigetflag
int	tigetflag(
		const char *str)
		{ return(*(int *)0); }

#undef tigetnum_sp
int	tigetnum_sp(
		SCREEN	*sp, 
		const char *str)
		{ return(*(int *)0); }

#undef tigetnum
int	tigetnum(
		const char *str)
		{ return(*(int *)0); }

#undef tigetstr_sp
char	*tigetstr_sp(
		SCREEN	*sp, 
		const char *str)
		{ return(*(char **)0); }

#undef tigetstr
char	*tigetstr(
		const char *str)
		{ return(*(char **)0); }

/* ./tinfo/lib_tparm.c */

#undef _nc_tparm_err
int	_nc_tparm_err;

#undef _nc_tparm_analyze
int	_nc_tparm_analyze(
		const char *string, 
		char	*p_is_s[9], 
		int	*_nc_popcount)
		{ return(*(int *)0); }

#undef tparm
char	*tparm(
		const char *string, 
		...)
		{ return(*(char **)0); }

#undef tiparm
char	*tiparm(
		const char *string, 
		...)
		{ return(*(char **)0); }

/* ./tinfo/lib_tputs.c */

#undef PC
char	PC;
#undef ospeed
short	ospeed;
#undef _nc_nulls_sent
int	_nc_nulls_sent;

#undef _nc_set_no_padding
void	_nc_set_no_padding(
		SCREEN	*sp)
		{ /* void */ }

#undef delay_output_sp
int	delay_output_sp(
		SCREEN	*sp, 
		int	ms)
		{ return(*(int *)0); }

#undef delay_output
int	delay_output(
		int	ms)
		{ return(*(int *)0); }

#undef _nc_flush_sp
void	_nc_flush_sp(
		SCREEN	*sp)
		{ /* void */ }

#undef _nc_flush
void	_nc_flush(void)
		{ /* void */ }

#undef _nc_outch_sp
int	_nc_outch_sp(
		SCREEN	*sp, 
		int	ch)
		{ return(*(int *)0); }

#undef _nc_outch
int	_nc_outch(
		int	ch)
		{ return(*(int *)0); }

#undef _nc_putchar_sp
int	_nc_putchar_sp(
		SCREEN	*sp, 
		int	ch)
		{ return(*(int *)0); }

#undef _nc_putchar
int	_nc_putchar(
		int	ch)
		{ return(*(int *)0); }

#undef putp_sp
int	putp_sp(
		SCREEN	*sp, 
		const char *string)
		{ return(*(int *)0); }

#undef putp
int	putp(
		const char *string)
		{ return(*(int *)0); }

#undef _nc_putp_sp
int	_nc_putp_sp(
		SCREEN	*sp, 
		const char *name, 
		const char *string)
		{ return(*(int *)0); }

#undef _nc_putp
int	_nc_putp(
		const char *name, 
		const char *string)
		{ return(*(int *)0); }

#undef tputs_sp
int	tputs_sp(
		SCREEN	*sp, 
		const char *string, 
		int	affcnt, 
		NCURSES_OUTC_sp outc)
		{ return(*(int *)0); }

#undef _nc_outc_wrapper
int	_nc_outc_wrapper(
		SCREEN	*sp, 
		int	c)
		{ return(*(int *)0); }

#undef tputs
int	tputs(
		const char *string, 
		int	affcnt, 
		int	(*outc)(
		int	p1))
		{ return(*(int *)0); }

/* ./trace/lib_trace.c */

#undef _nc_tracing
unsigned _nc_tracing;

#undef _nc__nc_tputs_trace
const char *_nc__nc_tputs_trace(void)
		{ return(*(const char **)0); }

#undef _nc__nc_outchars
long	_nc__nc_outchars(void)
		{ return(*(long *)0); }

#undef _nc_set_tputs_trace
void	_nc_set_tputs_trace(
		const char *s)
		{ /* void */ }

#undef _nc_count_outchars
void	_nc_count_outchars(
		long	increment)
		{ /* void */ }

#undef trace
void	trace(
		const unsigned int tracelevel)
		{ /* void */ }

#undef _tracef
void	_tracef(
		const char *fmt, 
		...)
		{ /* void */ }

#undef _nc_retrace_bool
NCURSES_BOOL _nc_retrace_bool(
		int	code)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_retrace_char
char	_nc_retrace_char(
		int	code)
		{ return(*(char *)0); }

#undef _nc_retrace_int
int	_nc_retrace_int(
		int	code)
		{ return(*(int *)0); }

#undef _nc_retrace_unsigned
unsigned _nc_retrace_unsigned(
		unsigned code)
		{ return(*(unsigned *)0); }

#undef _nc_retrace_ptr
char	*_nc_retrace_ptr(
		char	*code)
		{ return(*(char **)0); }

#undef _nc_retrace_cptr
const char *_nc_retrace_cptr(
		const char *code)
		{ return(*(const char **)0); }

#undef _nc_retrace_cvoid_ptr
const void *_nc_retrace_cvoid_ptr(
		const void *code)
		{ return(*(const void **)0); }

#undef _nc_retrace_void_ptr
void	*_nc_retrace_void_ptr(
		void	*code)
		{ return(*(void **)0); }

#undef _nc_retrace_sp
SCREEN	*_nc_retrace_sp(
		SCREEN	*code)
		{ return(*(SCREEN **)0); }

#undef _nc_retrace_win
WINDOW	*_nc_retrace_win(
		WINDOW	*code)
		{ return(*(WINDOW **)0); }

#undef _nc_use_tracef
int	_nc_use_tracef(
		unsigned mask)
		{ return(*(int *)0); }

#undef _nc_locked_tracef
void	_nc_locked_tracef(
		const char *fmt, 
		...)
		{ /* void */ }

/* ./trace/lib_traceatr.c */

#undef _traceattr2
char	*_traceattr2(
		int	bufnum, 
		chtype	newmode)
		{ return(*(char **)0); }

#undef _traceattr
char	*_traceattr(
		attr_t	newmode)
		{ return(*(char **)0); }

#undef _nc_retrace_int_attr_t
int	_nc_retrace_int_attr_t(
		attr_t	code)
		{ return(*(int *)0); }

#undef _nc_retrace_attr_t
attr_t	_nc_retrace_attr_t(
		attr_t	code)
		{ return(*(attr_t *)0); }

#undef _nc_altcharset_name
const char *_nc_altcharset_name(
		attr_t	attr, 
		chtype	ch)
		{ return(*(const char **)0); }

#undef _tracechtype2
char	*_tracechtype2(
		int	bufnum, 
		chtype	ch)
		{ return(*(char **)0); }

#undef _tracechtype
char	*_tracechtype(
		chtype	ch)
		{ return(*(char **)0); }

#undef _nc_retrace_chtype
chtype	_nc_retrace_chtype(
		chtype	code)
		{ return(*(chtype *)0); }

/* ./trace/lib_tracebits.c */

typedef struct {
    unsigned int val;
    const char name[8];
} BITNAMES;

#undef _nc_trace_ttymode
char	*_nc_trace_ttymode(
		struct termios *tty)
		{ return(*(char **)0); }

#undef _nc_tracebits
char	*_nc_tracebits(void)
		{ return(*(char **)0); }

/* ./trace/lib_tracechr.c */

#undef _nc_tracechar
char	*_nc_tracechar(
		SCREEN	*sp, 
		int	ch)
		{ return(*(char **)0); }

#undef _tracechar
char	*_tracechar(
		int	ch)
		{ return(*(char **)0); }

/* ./tinfo/lib_ttyflags.c */

#undef _nc_get_tty_mode_sp
int	_nc_get_tty_mode_sp(
		SCREEN	*sp, 
		struct termios *buf)
		{ return(*(int *)0); }

#undef _nc_get_tty_mode
int	_nc_get_tty_mode(
		struct termios *buf)
		{ return(*(int *)0); }

#undef _nc_set_tty_mode_sp
int	_nc_set_tty_mode_sp(
		SCREEN	*sp, 
		struct termios *buf)
		{ return(*(int *)0); }

#undef _nc_set_tty_mode
int	_nc_set_tty_mode(
		struct termios *buf)
		{ return(*(int *)0); }

#undef def_shell_mode_sp
int	def_shell_mode_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef def_shell_mode
int	def_shell_mode(void)
		{ return(*(int *)0); }

#undef def_prog_mode_sp
int	def_prog_mode_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef def_prog_mode
int	def_prog_mode(void)
		{ return(*(int *)0); }

#undef reset_prog_mode_sp
int	reset_prog_mode_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef reset_prog_mode
int	reset_prog_mode(void)
		{ return(*(int *)0); }

#undef reset_shell_mode_sp
int	reset_shell_mode_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef reset_shell_mode
int	reset_shell_mode(void)
		{ return(*(int *)0); }

#undef savetty_sp
int	savetty_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef savetty
int	savetty(void)
		{ return(*(int *)0); }

#undef resetty_sp
int	resetty_sp(
		SCREEN	*sp)
		{ return(*(int *)0); }

#undef resetty
int	resetty(void)
		{ return(*(int *)0); }

/* ./tty/lib_twait.c */

#undef _nc_timed_wait
int	_nc_timed_wait(
		SCREEN	*sp, 
		int	mode, 
		int	milliseconds, 
		int	*timeleft)
		{ return(*(int *)0); }

/* ./tinfo/name_match.c */

#undef _nc_first_name
char	*_nc_first_name(
		const char *const sp)
		{ return(*(char **)0); }

#undef _nc_name_match
int	_nc_name_match(
		const char *const namelst, 
		const char *const name, 
		const char *const delim)
		{ return(*(int *)0); }

/* ./names.c */

#undef _nc_boolnames
const char *const *_nc_boolnames(void)
		{ return(*(const char **)0); }

#undef _nc_boolfnames
const char *const *_nc_boolfnames(void)
		{ return(*(const char **)0); }

#undef _nc_numnames
const char *const *_nc_numnames(void)
		{ return(*(const char **)0); }

#undef _nc_numfnames
const char *const *_nc_numfnames(void)
		{ return(*(const char **)0); }

#undef _nc_strnames
const char *const *_nc_strnames(void)
		{ return(*(const char **)0); }

#undef _nc_strfnames
const char *const *_nc_strfnames(void)
		{ return(*(const char **)0); }

/* ./tinfo/obsolete.c */

#undef _nc_set_buffer_sp
void	_nc_set_buffer_sp(
		SCREEN	*sp, 
		FILE	*ofp, 
		int	buffered)
		{ /* void */ }

#undef _nc_set_buffer
void	_nc_set_buffer(
		FILE	*ofp, 
		int	buffered)
		{ /* void */ }

/* ./tinfo/read_entry.c */

#undef _nc_init_termtype
void	_nc_init_termtype(
		TERMTYPE *const tp)
		{ /* void */ }

#undef _nc_read_termtype
int	_nc_read_termtype(
		TERMTYPE *ptr, 
		char	*buffer, 
		int	limit)
		{ return(*(int *)0); }

#undef _nc_read_file_entry
int	_nc_read_file_entry(
		const char *const filename, 
		TERMTYPE *ptr)
		{ return(*(int *)0); }

#undef _nc_read_entry
int	_nc_read_entry(
		const char *const name, 
		char	*const filename, 
		TERMTYPE *const tp)
		{ return(*(int *)0); }

/* ./tinfo/read_termcap.c */

#undef _nc_read_termcap
void	_nc_read_termcap(void)
		{ /* void */ }

/* ./tinfo/strings.c */

#undef _nc_str_init
string_desc *_nc_str_init(
		string_desc *dst, 
		char	*src, 
		size_t	len)
		{ return(*(string_desc **)0); }

#undef _nc_str_null
string_desc *_nc_str_null(
		string_desc *dst, 
		size_t	len)
		{ return(*(string_desc **)0); }

#undef _nc_str_copy
string_desc *_nc_str_copy(
		string_desc *dst, 
		string_desc *src)
		{ return(*(string_desc **)0); }

#undef _nc_safe_strcat
NCURSES_BOOL _nc_safe_strcat(
		string_desc *dst, 
		const char *src)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_safe_strcpy
NCURSES_BOOL _nc_safe_strcpy(
		string_desc *dst, 
		const char *src)
		{ return(*(NCURSES_BOOL *)0); }

/* ./trace/trace_buf.c */

#undef _nc_trace_buf
char	*_nc_trace_buf(
		int	bufnum, 
		size_t	want)
		{ return(*(char **)0); }

#undef _nc_trace_bufcat
char	*_nc_trace_bufcat(
		int	bufnum, 
		const char *value)
		{ return(*(char **)0); }

/* ./trace/trace_tries.c */

#undef _nc_trace_tries
void	_nc_trace_tries(
		TRIES	*tree)
		{ /* void */ }

/* ./base/tries.c */

#undef _nc_expand_try
char	*_nc_expand_try(
		TRIES	*tree, 
		unsigned code, 
		int	*count, 
		size_t	len)
		{ return(*(char **)0); }

#undef _nc_remove_key
int	_nc_remove_key(
		TRIES	**tree, 
		unsigned code)
		{ return(*(int *)0); }

#undef _nc_remove_string
int	_nc_remove_string(
		TRIES	**tree, 
		const char *string)
		{ return(*(int *)0); }

/* ./tinfo/trim_sgr0.c */

#undef _nc_trim_sgr0
char	*_nc_trim_sgr0(
		TERMTYPE *tp)
		{ return(*(char **)0); }

/* ./unctrl.c */

#undef unctrl_sp
const char *unctrl_sp(
		SCREEN	*sp, 
		chtype	ch)
		{ return(*(const char **)0); }

#undef unctrl
const char *unctrl(
		chtype	ch)
		{ return(*(const char **)0); }

/* ./trace/visbuf.c */

#undef _nc_visbuf2
const char *_nc_visbuf2(
		int	bufnum, 
		const char *buf)
		{ return(*(const char **)0); }

#undef _nc_visbuf
const char *_nc_visbuf(
		const char *buf)
		{ return(*(const char **)0); }

#undef _nc_visbufn
const char *_nc_visbufn(
		const char *buf, 
		int	len)
		{ return(*(const char **)0); }

#undef _nc_viscbuf2
const char *_nc_viscbuf2(
		int	bufnum, 
		const chtype *buf, 
		int	len)
		{ return(*(const char **)0); }

#undef _nc_viscbuf
const char *_nc_viscbuf(
		const chtype *buf, 
		int	len)
		{ return(*(const char **)0); }

/* ./tinfo/alloc_entry.c */

#undef _nc_init_entry
void	_nc_init_entry(
		TERMTYPE *const tp)
		{ /* void */ }

#undef _nc_copy_entry
ENTRY	*_nc_copy_entry(
		ENTRY	*oldp)
		{ return(*(ENTRY **)0); }

#undef _nc_save_str
char	*_nc_save_str(
		const char *const string)
		{ return(*(char **)0); }

#undef _nc_wrap_entry
void	_nc_wrap_entry(
		ENTRY	*const ep, 
		NCURSES_BOOL copy_strings)
		{ /* void */ }

#undef _nc_merge_entry
void	_nc_merge_entry(
		TERMTYPE *const to, 
		TERMTYPE *const from)
		{ /* void */ }

/* ./tinfo/captoinfo.c */

#undef _nc_captoinfo
char	*_nc_captoinfo(
		const char *cap, 
		const char *s, 
		int const parameterized)
		{ return(*(char **)0); }

#undef _nc_infotocap
char	*_nc_infotocap(
		const char *cap, 
		const char *str, 
		int const parameterized)
		{ return(*(char **)0); }

/* ./tinfo/comp_expand.c */

#undef _nc_tic_expand
char	*_nc_tic_expand(
		const char *srcp, 
		NCURSES_BOOL tic_format, 
		int	numbers)
		{ return(*(char **)0); }

/* ./tinfo/comp_parse.c */

#undef _nc_check_termtype2
void	(*_nc_check_termtype2)(
		TERMTYPE *p1, 
		NCURSES_BOOL p2);
#undef _nc_check_termtype
void	(*_nc_check_termtype)(
		TERMTYPE *p1);

#undef _nc_entry_match
NCURSES_BOOL _nc_entry_match(
		char	*n1, 
		char	*n2)
		{ return(*(NCURSES_BOOL *)0); }

#undef _nc_read_entry_source
void	_nc_read_entry_source(
		FILE	*fp, 
		char	*buf, 
		int	literal, 
		NCURSES_BOOL silent, 
		NCURSES_BOOL (*hook)(
		ENTRY	*p1))
		{ /* void */ }

#undef _nc_resolve_uses2
int	_nc_resolve_uses2(
		NCURSES_BOOL fullresolve, 
		NCURSES_BOOL literal)
		{ return(*(int *)0); }

#undef _nc_resolve_uses
int	_nc_resolve_uses(
		NCURSES_BOOL fullresolve)
		{ return(*(int *)0); }

/* ./tinfo/comp_scan.c */

#undef _nc_syntax
int	_nc_syntax;
#undef _nc_strict_bsd
int	_nc_strict_bsd;
#undef _nc_curr_file_pos
long	_nc_curr_file_pos;
#undef _nc_comment_start
long	_nc_comment_start;
#undef _nc_comment_end
long	_nc_comment_end;
#undef _nc_start_line
long	_nc_start_line;
#undef _nc_curr_token
struct token _nc_curr_token;
#undef _nc_disable_period
NCURSES_BOOL _nc_disable_period;

#undef _nc_reset_input
void	_nc_reset_input(
		FILE	*fp, 
		char	*buf)
		{ /* void */ }

#undef _nc_get_token
int	_nc_get_token(
		NCURSES_BOOL silent)
		{ return(*(int *)0); }

#undef _nc_trans_string
int	_nc_trans_string(
		char	*ptr, 
		char	*last)
		{ return(*(int *)0); }

#undef _nc_push_token
void	_nc_push_token(
		int	tokclass)
		{ /* void */ }

#undef _nc_panic_mode
void	_nc_panic_mode(
		char	ch)
		{ /* void */ }

/* ./tinfo/parse_entry.c */

#undef _nc_parse_entry
int	_nc_parse_entry(
		struct entry *entryp, 
		int	literal, 
		NCURSES_BOOL silent)
		{ return(*(int *)0); }

#undef _nc_capcmp
int	_nc_capcmp(
		const char *s, 
		const char *t)
		{ return(*(int *)0); }

typedef struct {
    const char from[3];
    const char to[6];
} assoc;

/* ./tinfo/write_entry.c */

#undef _nc_set_writedir
void	_nc_set_writedir(
		const char *dir)
		{ /* void */ }

#undef _nc_write_entry
void	_nc_write_entry(
		TERMTYPE *const tp)
		{ /* void */ }

#undef _nc_tic_written
int	_nc_tic_written(void)
		{ return(*(int *)0); }

/* ./base/define_key.c */

#undef define_key_sp
int	define_key_sp(
		SCREEN	*sp, 
		const char *str, 
		int	keycode)
		{ return(*(int *)0); }

#undef define_key
int	define_key(
		const char *str, 
		int	keycode)
		{ return(*(int *)0); }

/* ./tinfo/hashed_db.c */

#undef _nc_hashed_db
void	_nc_hashed_db(void)
		{ /* void */ }

/* ./base/key_defined.c */

#undef key_defined_sp
int	key_defined_sp(
		SCREEN	*sp, 
		const char *str)
		{ return(*(int *)0); }

#undef key_defined
int	key_defined(
		const char *str)
		{ return(*(int *)0); }

/* ./base/keybound.c */

#undef keybound_sp
char	*keybound_sp(
		SCREEN	*sp, 
		int	code, 
		int	count)
		{ return(*(char **)0); }

#undef keybound
char	*keybound(
		int	code, 
		int	count)
		{ return(*(char **)0); }

/* ./base/keyok.c */

#undef keyok_sp
int	keyok_sp(
		SCREEN	*sp, 
		int	c, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

#undef keyok
int	keyok(
		int	c, 
		NCURSES_BOOL flag)
		{ return(*(int *)0); }

/* ./base/version.c */

#undef curses_version
const char *curses_version(void)
		{ return(*(const char **)0); }