/****************************************************************************
 * Copyright 2019,2020,2021 Thomas E. Dickey                                *
 * Copyright 2008-2016,2017 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	pair_arg,
		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 _nc_change_pair
void	_nc_change_pair(
		SCREEN	*sp,
		int	pair)
		{ /* void */ }

#undef _nc_reserve_pairs
void	_nc_reserve_pairs(
		SCREEN	*sp,
		int	want)
		{ /* void */ }

#undef _nc_init_pair
int	_nc_init_pair(
		SCREEN	*sp,
		int	pair,
		int	f,
		int	b)
		{ 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 _nc_init_color
int	_nc_init_color(
		SCREEN	*sp,
		int	color,
		int	r,
		int	g,
		int	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 _nc_pair_content
int	_nc_pair_content(
		SCREEN	*sp,
		int	pair,
		int	*f,
		int	*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	pair_arg,
		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 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); }

#undef vw_printw
int	vw_printw(
		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 vw_scanw
int	vw_scanw(
		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	pair_arg,
		void	*opts)
		{ return(*(int *)0); }

#undef slk_attr_set
int	slk_attr_set(
		const attr_t attr,
		short	pair_arg,
		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	pair_arg)
		{ return(*(int *)0); }

#undef slk_color
int	slk_color(
		short	pair_arg)
		{ 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 */

#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 */ }

#undef exit_curses
void	exit_curses(
		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/new_pair.c */

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

/* ./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); }

#undef _nc_safe_fopen
FILE	*_nc_safe_fopen(
		const char *path,
		const char *mode)
		{ return(*(FILE **)0); }

#undef _nc_safe_open3
int	_nc_safe_open3(
		const char *path,
		int	flags,
		mode_t	mode)
		{ 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); }

#undef _nc_find_user_entry
struct user_table_entry const *_nc_find_user_entry(
		const char *string)
		{ return(*(struct user_table_entry const **)0); }

/* ./comp_userdefs.c */

#undef _nc_get_userdefs_table
const struct user_table_entry *_nc_get_userdefs_table(void)
		{ return(*(const struct user_table_entry **)0); }

#undef _nc_get_hash_user
const HashData *_nc_get_hash_user(void)
		{ return(*(const HashData **)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_leaks_tinfo
void	_nc_leaks_tinfo(void)
		{ /* void */ }

#undef exit_terminfo
void	exit_terminfo(
		int	code)
		{ /* 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 {
    int given_speed;
    int actual_speed;
};

#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 _nc_find_prescr
SCREEN	*_nc_find_prescr(void)
		{ return(*(SCREEN **)0); }

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

#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(
		TERMINAL *term,
		const char *string,
		char	**p_is_s,
		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); }

#undef _nc_tiparm
char	*_nc_tiparm(
		int	expected,
		const char *string,
		...)
		{ return(*(char **)0); }

#undef _nc_reset_tparm
void	_nc_reset_tparm(
		TERMINAL *term)
		{ /* void */ }

/* ./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 curses_trace
unsigned curses_trace(
		unsigned tracelevel)
		{ return(*(unsigned *)0); }

#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_fmt_funcptr
char	*_nc_fmt_funcptr(
		char	*target,
		const char *source,
		size_t	size)
		{ return(*(char **)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 */

#undef _nc_trace_ttymode
char	*_nc_trace_ttymode(
		const 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_entry
int	_nc_read_termcap_entry(
		const char *const tn,
		TERMTYPE *const tp)
		{ return(*(int *)0); }

/* ./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(
		ENTRY	*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 *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(
		ENTRY	*const target,
		ENTRY	*const source)
		{ /* 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_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); }

/* ./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(
		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); }

/* ./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_write_object
int	_nc_write_object(
		TERMTYPE *tp,
		char	*buffer,
		unsigned *offset,
		unsigned limit)
		{ return(*(int *)0); }

#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); }