+#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_tracemouse
+char *_nc_tracemouse(
+ SCREEN *sp,
+ MEVENT const *ep)
+ { return(*(char **)0); }
+
+#undef _tracemouse
+char *_tracemouse(
+ MEVENT const *ep)
+ { return(*(char **)0); }
+
+/* ./tty/lib_tstp.c */
+
+#include <SigAction.h>
+
+#undef _nc_signal_handler
+void _nc_signal_handler(
+ NCURSES_BOOL 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 */
+
+#include <sys/time.h>
+#include <sys/times.h>
+
+#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/memmove.c */
+
+#undef _nc_memmove
+void _nc_memmove(void)
+ { /* void */ }
+
+/* ./base/vsscanf.c */
+
+#undef _nc_vsscanf
+void _nc_vsscanf(void)
+ { /* void */ }
+
+/* ./base/lib_freeall.c */
+
+#include <term_entry.h>
+
+#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 */
+
+#include <term.h>
+
+#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 */
+
+#include <sys/stat.h>
+#include <nc_alloc.h>
+
+#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,
+ TERMTYPE *src)
+ { /* void */ }
+
+/* ./codes.c */
+
+#undef boolcodes
+char *const boolcodes[] = {0};
+#undef numcodes
+char *const numcodes[] = {0};
+#undef strcodes
+char *const strcodes[] = {0};
+
+/* ./comp_captab.c */
+
+#include <hashsize.h>
+
+#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); }
+
+/* ./tinfo/home_terminfo.c */
+
+#undef _nc_home_terminfo
+char *_nc_home_terminfo(void)
+ { return(*(char **)0); }
+
+/* ./tinfo/init_keytry.c */
+
+#if 0
+
+#include <init_keytry.h>
+
+#undef _nc_tinfo_fkeys
+const struct tinfo_fkeys _nc_tinfo_fkeys[] = {0};
+
+#endif
+
+#undef _nc_init_keytry
+void _nc_init_keytry(
+ SCREEN *sp)
+ { /* void */ }
+
+/* ./tinfo/lib_acs.c */
+
+#undef acs_map
+chtype acs_map[128];
+
+#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 */
+
+#include <termcap.h>
+
+struct speed {
+ int 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 cur_term
+TERMINAL *cur_term;
+
+#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 stdscr
+WINDOW *stdscr;
+#undef curscr
+WINDOW *curscr;
+#undef newscr
+WINDOW *newscr;
+#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); }
+
+/* ./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
+char *keyname_sp(
+ SCREEN *sp,
+ int c)
+ { return(*(char **)0); }
+
+#undef keyname
+char *keyname(
+ int c)
+ { return(*(char **)0); }
+
+/* ./tinfo/lib_longname.c */
+
+#undef longname
+char *longname(void)
+ { return(*(char **)0); }
+
+/* ./tinfo/lib_napms.c */
+
+#include <time.h>
+
+#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,
+ NCURSES_BOOL 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 */
+
+#include <locale.h>
+#include <sys/ioctl.h>
+#include <langinfo.h>
+
+#undef ttytype
+char ttytype[256];
+#undef LINES
+int LINES;
+#undef COLS
+int COLS;
+#undef TABSIZE
+int TABSIZE;
+
+#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_env
+void use_env(
+ 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_tinfo_cmdch
+void _nc_tinfo_cmdch(
+ TERMINAL *termp,
+ char 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(
+ char *tname,
+ int Filedes,
+ int *errret,
+ NCURSES_BOOL reuse)
+ { return(*(int *)0); }
+
+#undef new_prescr
+SCREEN *new_prescr(void)
+ { return(*(SCREEN **)0); }
+
+#undef setupterm
+int setupterm(
+ 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); }
+
+#if 0
+
+#include <capdefaults.c>
+
+#endif
+
+#undef tgetent
+int tgetent(
+ char *bufp,
+ const char *name)
+ { return(*(int *)0); }
+
+#undef tgetflag_sp
+int tgetflag_sp(
+ SCREEN *sp,
+ char *id)
+ { return(*(int *)0); }
+
+#undef tgetflag
+int tgetflag(
+ char *id)
+ { return(*(int *)0); }
+
+#undef tgetnum_sp
+int tgetnum_sp(
+ SCREEN *sp,
+ char *id)
+ { return(*(int *)0); }
+
+#undef tgetnum
+int tgetnum(
+ char *id)
+ { return(*(int *)0); }
+
+#undef tgetstr_sp
+char *tgetstr_sp(
+ SCREEN *sp,
+ char *id,
+ char **area)
+ { return(*(char **)0); }
+
+#undef tgetstr
+char *tgetstr(
+ 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,
+ char *str)
+ { return(*(int *)0); }
+
+#undef tigetflag
+int tigetflag(
+ char *str)
+ { return(*(int *)0); }
+
+#undef tigetnum_sp
+int tigetnum_sp(
+ SCREEN *sp,
+ char *str)
+ { return(*(int *)0); }
+
+#undef tigetnum
+int tigetnum(
+ char *str)
+ { return(*(int *)0); }