/*LINTLIBRARY*/
#include "Xlib.h"
#include "Xatom.h"
#include "Xos.h"
#include "Xutil.h"
#include "Xresource.h"

Status	XAllocColorCells(display, cmap, contig, masks, nplanes, pixels, ncolors)
	    Display *display;Colormap cmap;Bool contig;
	    unsigned int ncolors; unsigned int nplanes; unsigned long masks[];
	    unsigned long pixels[]; 
	    {return ((Status)0);}

Status	XAllocColorPlanes(display, cmap, contig, pixels, ncolors, nreds,
	    ngreens, nblues, rmask, gmask, bmask)
	    Display *display;Colormap cmap;Bool contig;
	    unsigned long pixels[]; int ncolors;int nreds, ngreens, nblues;
	    unsigned long *rmask, *gmask, *bmask; 
	    {return ((Status)0);}

	XAllowEvents(display, mode, time)
	    Display *display; int mode; Time time;
	    {;}

	XAutoRepeatOff (display) 
	    Display *display;
	    {;}

	XAutoRepeatOn (display) 
	    Display *display;
	    {;}

	XSetWindowBackground(display, w, pixel)
	    Display *display; Window w; unsigned long pixel;
	    {;}

	XSetWindowBorderWidth(display, w, width)
	    Display *display;Window w;unsigned int width;
	    {;}

	XBell(display, percent)
	    Display *display; int percent;
	    {;}

	XSetWindowBorder(display, w, pixel)
	    Display *display; Window w; unsigned long pixel;
	    {;}

	XDisableAccessControl(display)      
	    Display *display;
	    {;}
	    
	XEnableAccessControl(display)
	    Display *display;
	    {;}

	XSetAccessControl(display, mode)
	    Display *display; int mode;
	    {;}

	XChangeActivePointerGrab(display, event_mask, curs, time)
	    Display *display;unsigned int event_mask; Cursor curs;
	    Time time;
	    {;}

	XSetCloseDownMode(display, mode)
	    Display *display; int mode;
	    {;}

	XSetWindowColormap(display, w, colormap)
	    Display *display; Window w; Colormap colormap;
	    {;}

	XChangeGC (display, gc, valuemask, values)
	    Display *display; GC gc; unsigned long valuemask;
	    XGCValues *values;
	    {;}

	XChangeKeyboardControl(display, mask, value_list)
	    Display *display; unsigned long mask;
	    XKeyboardControl *value_list;
	    {;}

	XChangePointerControl(display, do_acc, do_thresh, acc_numerator,
	     acc_denominator, threshold)
	    Display *display; Bool do_acc, do_thresh;
	    int acc_numerator, acc_denominator, threshold;
	    {;}

	XChangeProperty (display, w, property, type, format, mode, data, nelements)
	    Display *display; Window w; Atom property, type; int format;
	    int mode; unsigned char *data; int nelements; 
	    {;}

	XAddToSaveSet(display, win)
	    Display *display; Window win;
	    {;}

	XChangeSaveSet(display, win, mode)
	    Display *display;Window win;int mode;
	    {;}

	XRemoveFromSaveSet (display, win)
	    Display *display; Window win;
	    {;}

	XChangeWindowAttributes (display, w, valuemask, attributes)
	    Display *display; Window w; unsigned long valuemask;
	    XSetWindowAttributes *attributes;
	    {;}

	XResizeWindow(display, w, width, height)
	    Display *display;Window w;unsigned int width, height;
	    {;}

Bool	XCheckIfEvent (display, event, predicate, arg)
	    Display *display; Bool (*predicate)(); XEvent *event;
	    char *arg;
	    {return ((Bool)0);}

Bool	XCheckMaskEvent (display, mask, event)
	    Display *display; long mask; XEvent *event; 
	    {return ((Bool)0);}

Bool	XCheckTypedEvent (display, type, event)
	    Display *display; int type; XEvent *event; 
	    {return ((Bool)0);}

Bool	XCheckTypedWindowEvent (display, w, type, event)
	    Display *display; Window w; int type; XEvent *event;
	    {return ((Bool)0);}

Bool	XCheckWindowEvent (display, w, mask, event)
	    Display *display; Window w; long mask; XEvent *event;
	    {return ((Bool)0);}

	XCirculateSubwindows(display, w, direction)
	    Display *display; Window w; int direction;
	    {;}

	XCirculateSubwindowsDown(display,w)
	    Display *display; Window w;
	    {;}

	XCirculateSubwindowsUp(display, w)
	    Display *display; Window w;
	    {;}

	XCloseDisplay (display)  
	    Display *display;
	    {;}

	XClearWindow(display, w)     
	    Display *display;    Window w;
	    {;}

	XClearArea (display, w, x, y, width, height, exposures)
	    Display *display; Window w; int x, y;
	    unsigned int width, height; Bool exposures;
	    {;}

	XMoveResizeWindow(display, w, x, y, width, height)
	    Display *display;Window w;int x, y;unsigned int width, height;
	    {;}

	XConvertSelection(display, selection, target, property, requestor, time)
	    Display *display;Atom selection, target;Atom property;
	    Window requestor;Time time;
	    {;}

	XCopyArea(display, src_drawable, dst_drawable, gc, src_x, src_y,
	     width, height, dst_x, dst_y)
	    Display *display; Drawable src_drawable, dst_drawable; 
	    GC gc; int src_x, src_y; unsigned int width, height;
	    int dst_x, dst_y;
	    {;}

Colormap	XCopyColormapAndFree(display, src_cmap)
	    Display *display;Colormap src_cmap;
	    {return ((Colormap)0);}

	XCopyGC (display, srcGC, mask, destGC)
	    Display *display; unsigned long mask; GC srcGC, destGC;
	    {;}

	XCopyPlane(display, src_drawable, dst_drawable, gc, src_x, src_y,
	     width, height, dst_x, dst_y, bit_plane)
	    Display *display; Drawable src_drawable, dst_drawable; 
	    GC gc; int src_x, src_y; unsigned int width, height;
	    int dst_x, dst_y; unsigned long bit_plane;
	    {;}

Pixmap	XCreateBitmapFromData(display, d, data, width, height)
	    Display *display; Drawable d; char *data;
	    unsigned int width, height;
	    {return ((Pixmap)0);}

Colormap	XCreateColormap(display, w, visual, alloc)
	    Display *display;Window w;Visual *visual;int alloc;
	    {return ((Colormap)0);}

Cursor	XCreatePixmapCursor(display, source, mask, foreground, background, x, y)
	    Display *display; Pixmap source, mask;
	    XColor *foreground, *background; unsigned int x, y;
	    {return ((Cursor)0);}

GC	XCreateGC (display, d, valuemask, values)
	    Display *display; Drawable d; unsigned long valuemask;
	    XGCValues *values; 
	    {return ((GC)0);}

GContext	XGContextFromGC(gc)
	    GC gc; 
	    {return ((GContext)0);}

Cursor	XCreateGlyphCursor(display, source_font, mask_font, source_char,
	     mask_char, foreground, background)
	    Display *display; Font source_font, mask_font;
	    unsigned int source_char, mask_char;
	    XColor *foreground, *background;
	    {return ((Cursor)0);}

Pixmap	XCreatePixmapFromBitmapData(display,d,data,width,height,fg,bg, depth)
	    Display *display; Drawable d; char *data;
	    unsigned int width, height; unsigned long fg, bg;
	    unsigned int depth;
	    {return ((Pixmap)0);}

Pixmap	XCreatePixmap (display, d, width, height, depth)
	    Display *display; Drawable d;
	    unsigned int width, height, depth;
	    {return ((Pixmap)0);}

Window	XCreateSimpleWindow(display, parent, x, y, width, height, borderWidth,
	     border, background)
	    Display *display; Window parent; int x, y;
	    unsigned int width, height, borderWidth; unsigned long border;
	    unsigned long background;
	    {return ((Window)0);}

Cursor	XCreateFontCursor(display, which)
	    Display *display; unsigned int which;
	    {return ((Cursor)0);}

	XDefineCursor (display, w, cursor)
	    Display *display; Window w; Cursor cursor;
	    {;}

	XDeleteProperty (display, window, property)
	    Display *display;Window window;Atom property;
	    {;}

	XDestroySubwindows (display, win)
	    Display *display;Window win;
	    {;}

	XDestroyWindow (display, w)  
	    Display *display; Window w;
	    {;}

char *	XDisplayName (display)
	    char *display;
	    {return ((char *)0);}

	XDrawArc(display, d, gc, x, y, width, height, angle1, angle2)
	    Display *display; Drawable d; GC gc; int x, y;
	    unsigned int width, height; int angle1, angle2; 
	    {;}

	XDrawArcs(display, d, gc, arcs, n_arcs)
	    Display *display;Drawable d;GC gc;XArc *arcs;int n_arcs;
	    {;}

	XDrawLine (display, d, gc, x1, y1, x2, y2)
	    Display *display; Drawable d; GC gc; int x1, y1, x2, y2;
	    {;}

	XDrawLines (display, d, gc, points, npoints, mode)
	    Display *display; Drawable d; GC gc; XPoint *points;
	    int npoints; int mode;
	    {;}

	XDrawPoint(display, d, gc, x, y)
	    Display *display; Drawable d; GC gc; int x, y; 
	    {;}

	XDrawPoints(display, d, gc, points, n_points, mode)
	    Display *display; Drawable d; GC gc; XPoint *points;
	    int n_points; int mode; 
	    {;}

	XDrawRectangle(display, d, gc, x, y, width, height)
	    Display *display; Drawable d; GC gc; int x, y;
	    unsigned int width, height; 
	    {;}

	XDrawRectangles(display, d, gc, rects, n_rects)
	    Display *display;Drawable d;GC gc;XRectangle *rects;
	    int n_rects;
	    {;}

	XDrawSegments (display, d, gc, segments, nsegments)
	    Display *display; Drawable d; GC gc; XSegment *segments;
	    int nsegments;
	    {;}

	XGetErrorDatabaseText(display, name, type, defaultp, buffer, nbytes)
	    Display *display; char *name, *type; char *defaultp; 
	    char *buffer; int nbytes;
	    {;}

	XActivateScreenSaver(display)      
	    Display *display;
	    {;}

	XForceScreenSaver(display, mode)
	    Display *display; int mode;
	    {;}

	XResetScreenSaver(display)      
	    Display *display;
	    {;}

Status	XFetchName (display, w, name)
	    Display *display; Window w; char **name;
	    {return ((Status)0);}

Status	XGetIconName (display, w, icon_name)
	    Display *display; Window w; char **icon_name;
	    {return ((Status)0);}

	XFillArc(display, d, gc, x, y, width, height, angle1, angle2)
	    Display *display; Drawable d; GC gc; int x, y;
	    unsigned int width, height; int angle1, angle2; 
	    {;}

	XFillArcs(display, d, gc, arcs, n_arcs)
	    Display *display;Drawable d;GC gc;XArc *arcs;int n_arcs;
	    {;}

	XFillPolygon(display, d, gc, points, n_points, shape, mode)
	    Display *display;Drawable d;GC gc;XPoint *points;int n_points;
	    int shape;int mode;
	    {;}

	XFillRectangle(display, d, gc, x, y, width, height)
	    Display *display; Drawable d; GC gc; int x, y;
	    unsigned int width, height; 
	    {;}

	XFillRectangles(display, d, gc, rectangles, n_rects)
	    Display *display;Drawable d;GC gc;XRectangle *rectangles;
	    int n_rects;
	    {;}

	XFlush (display)     
	    Display *display;
	    {;}

	XFreeFont(display, fs)
	    Display *display; XFontStruct *fs;
	    {;}

XFontStruct *	XQueryFont (display, fid)
	    Display *display; Font fid;
	    {return ((XFontStruct *)0);}

XFontStruct *	XLoadQueryFont(display, name) 
	    Display *display; char *name;
	    {return ((XFontStruct *)0);}

char **	XListFontsWithInfo(display, pattern, maxNames, actualCount, info)
	    Display *display;char *pattern; int maxNames;int *actualCount;
	    XFontStruct **info;
	    {return ((char **)0);}

	XFreeFontInfo (names, info, actualCount)
	    char **names;XFontStruct *info;int actualCount;
	    {;}

char **	XListFonts(display, pattern, maxNames, actualCount)
	    Display *display;char *pattern; int maxNames;int *actualCount;
	    {return ((char **)0);}

	XFreeFontNames(list) 
	    char **list;
	    {;}

	XFreeColormap(display, cmap)
	    Display *display;Colormap cmap;
	    {;}

	XFreeColors(display, cmap, pixels, npixels, planes)
	    Display *display;Colormap cmap;unsigned long *pixels;
	    int npixels;unsigned long planes; 
	    {;}

	XFreeCursor(display, cursor)
	    Display *display; Cursor cursor;
	    {;}

	XFreeGC (display, gc)     
	    Display *display;    GC gc;
	    {;}

	XFreePixmap(display, pixmap)
	    Display *display; Pixmap pixmap;
	    {;}

	XSetArcMode (display, gc, arc_mode)
	    Display *display;GC gc;int arc_mode;
	    {;}

	XSetFillRule (display, gc, fill_rule)
	    Display *display;GC gc;int fill_rule;
	    {;}

	XSetFillStyle (display, gc, fill_style)
	    Display *display;GC gc;int fill_style;
	    {;}

	XSetGraphicsExposures (display, gc, graphics_exposures)
	    Display *display;GC gc;Bool graphics_exposures;
	    {;}

	XSetSubwindowMode (display, gc, subwindow_mode)
	    Display *display;GC gc;int subwindow_mode;
	    {;}

int	XGeometry (display, screen, pos, def, bwidth, fwidth, fheight, xadd,
	     yadd, x, y, width, height)
	    Display *display; int screen; char *pos; char *def; unsigned int bwidth;
	    unsigned int fwidth, fheight; int xadd, yadd;
	    int *x, *y, *width, *height; 
	    {return ((int)0);}

char *	XGetAtomName(display, atom)
	    Display *display;Atom atom;
	    {return ((char *)0);}

Status	XAllocNamedColor(display, cmap, colorname, hard_def, exact_def)
	    Display *display;Colormap cmap;char *colorname;
	    XColor *hard_def; XColor *exact_def; 
	    {return ((Status)0);}

char *	XGetDefault(display, prog, name)
	    Display *display; char *name; char *prog; 
	    {return ((char *)0);}

char **	XGetFontPath(display, npaths)
	    Display *display;int *npaths;
	    {return ((char **)0);}

	XFreeFontPath (list) 
	    char **list;
	    {;}

Bool	XGetFontProperty (fs, name, valuePtr)
	    XFontStruct *fs; Atom name; unsigned long *valuePtr; 
	    {return ((Bool)0);}

Status	XGetGeometry (display, d, root, x, y, width, height, borderWidth, depth)
	    Display *display; Drawable d; Window *root; int *x, *y;
	    unsigned int *width, *height, *borderWidth, *depth; 
	    {return ((Status)0);}

Status	XAllocColor(display, cmap, def)
	    Display *display;Colormap cmap;XColor *def;
	    {return ((Status)0);}

	XGetClassHint(display, w, classhint)
	    Display *display; Window w; XClassHint *classhint;
	    {return (0);}

Status	XGetCommand (display, w, argvp, argcp)
	    Display *display; Window w; char ***argvp; int *argcp;
	    {return ((Status)0);}

Status 	XGetIconSizes (display, w, size_list, count)
	    Display *display; Window w; XIconSize **size_list; int *count; 
	    {return ((Status)0);}

	XGetNormalHints (display, w, hints)
	    Display *display; Window w; XSizeHints *hints;
	    {return (0);}

	XGetTransientForHint(display, w, propWindow)
	    Display *display; Window w; Window *propWindow;
	    {return (0);}

XWMHints *	XGetWMHints (display, w)
	    Display *display; Window w;
	    {return ((XWMHints *)0);}

	XGetZoomHints (display, w, zhints)
	    Display *display; Window w; XSizeHints *zhints;
	    {return (0);}

	XGetInputFocus(display, focus, revert_to)
	    Display *display; Window *focus; int *revert_to;
	    {;}

XImage *	XGetImage (display, d, x, y, width, height, plane_mask, format)
	    Display *display; Drawable d; int x, y; 
	    unsigned int width, height; unsigned long plane_mask; int format; 
	    {return ((XImage *)0);}

XImage *	XGetSubImage(display, d, x, y, width, height, plane_mask,
	     format, dest_image, dest_x, dest_y)
	    Display *display; Drawable d; int x, y;
	    unsigned int width, height; unsigned long plane_mask; int format;
	    XImage *dest_image; int dest_x, dest_y;
	    {return ((XImage *)0);}

	XGetKeyboardControl (display, state)
	    Display *display; XKeyboardState *state; 
	    {;}

XTimeCoord *	XGetMotionEvents(display, w, start, stop, nEvents)
	    Display *display; Time start, stop; Window w; int *nEvents;
	    {return ((XTimeCoord *)0);}

	XGetPointerControl(display, accel_numer, accel_denom, threshold)
	    Display *display; int *accel_numer, *accel_denom;
	    int *threshold;
	    {;}


KeySym *	XGetKeyboardMapping (display, first_keycode, count,
	    keysyms_per_keycode)
	    Display *display; KeyCode first_keycode; int count;
	    int *keysyms_per_keycode;
	    {return ((KeySym *)0);}

int	XGetPointerMapping (display, map, nmaps)
	    Display *display; unsigned char map[]; int nmaps;
	    {return ((int)0);}

	XGetWindowProperty(display, w, property, offset, length, delete,
	    req_type, actual_type, actual_format, nitems, bytesafter, prop)
	    Display *display; Window w; Atom property; Bool delete;
	    Atom req_type; Atom *actual_type; int *actual_format;
	    long offset, length; unsigned long *nitems;
	    unsigned long *bytesafter; unsigned char **prop; 
	    {return (0);}

Window	XGetSelectionOwner(display, selection)
	    Display *display;Atom selection;
	    {return ((Window)0);}

	XGetScreenSaver(display, timeout, interval, prefer_blanking, allow_exp)
	    Display *display; int *timeout, *interval;
	    int *prefer_blanking, *allow_exp; 
	    {;}

Status	XGetWindowAttributes(display, w, att)
	    Display *display; Window w; XWindowAttributes *att;
	    {return ((Status)0);}

	XGrabButton(display, button, modifiers, grab_window, owner_events,
	     event_mask, pointer_mode, keyboard_mode, confine_to, curs)
	    Display *display;unsigned int modifiers; unsigned int button;
	    Window grab_window;Bool owner_events;unsigned int event_mask;
	    int pointer_mode, keyboard_mode;Window confine_to;Cursor curs;
	    {;}

	XGrabKey(display, key, modifiers, grab_window, owner_events,
	     pointer_mode, keyboard_mode)
	    Display *display; int key; unsigned int modifiers; 
	    Window grab_window; Bool owner_events;
	    int pointer_mode, keyboard_mode;
	    {;}

int	XGrabKeyboard (display, window, ownerEvents, pointerMode, keyboardMode,
	    time)
	    Display *display; Window window; Bool ownerEvents;
	    int pointerMode, keyboardMode; Time time;
	    {return ((int)0);}

int	XGrabPointer(display, grab_window, owner_events, event_mask, pointer_mode,
	    keyboard_mode, confine_to, curs, time)
	    Display *display;Window grab_window;Bool owner_events;
	    unsigned int event_mask; int pointer_mode, keyboard_mode;
	    Window confine_to;Cursor curs;Time time;
	    {return ((int)0);}

	XGrabServer (display) 
	    Display *display;
	    {;}

	XAddHost (display, host)
	    Display *display; XHostAddress *host; 
	    {;}

	XAddHosts (display, hosts, n)
	    Display *display; XHostAddress *hosts; int n;
	    {;}

	XRemoveHost (display, host)
	    Display *display; XHostAddress *host; 
	    {;}

	XRemoveHosts (display, hosts, n)
	    Display *display; XHostAddress *hosts; int n;
	    {;}

	XIfEvent (display, event, predicate, arg)
	    Display *display; Bool (*predicate)(); XEvent *event;
	    char *arg;
	    {;}

	XDrawImageString(display, d, gc, x, y, string, length)
	    Display *display; Drawable d; GC gc; int x, y; char *string; 
	    int length;
	    {;}

	XDrawImageString16(display, d, gc, x, y, string, length)
	    Display *display; Drawable d; GC gc; int x, y; XChar2b *string;
	    int length;
	    {;}

XImage *	XCreateImage (display, visual, depth, format, offset, data,
	     width, height, xpad, image_bytes_per_line)
	    Display *display; Visual *visual; unsigned int depth;
	    int format; int offset; char *data; unsigned int width;
	    unsigned int height; int xpad; int image_bytes_per_line; 
	    {return ((XImage *)0);}

XExtData **	XEHeadOfExtensionList(object)
	    XEDataObject object;
	    {return ((XExtData **)0);}

XExtCodes *	XAddExtension (display)
	    Display *display;
	    {return ((XExtCodes *)0);}

	XAddToExtensionList(structure, ext_data)
	    XExtData **structure; XExtData *ext_data;
	    {;}

XExtData *	XFindOnExtensionList(structure, number)
	    XExtData **structure; int number;
	    {return ((XExtData *)0);}

XExtCodes *	XInitExtension (display, name)
	    Display *display; char *name;
	    {return ((XExtCodes *)0);}

	XInstallColormap(display, cmap)
	    Display *display;Colormap cmap;
	    {;}

Atom	XInternAtom (display, name, onlyIfExists)
	    Display *display; char *name; Bool onlyIfExists;
	    {return ((Atom)0);}

KeySym	XKeycodeToKeysym(display, kc, col)
	    Display *display; KeyCode kc; int col;
	    {return ((KeySym)0);}

KeyCode	XKeysymToKeycode(display, ks)
	    Display *display; KeySym ks;
	    {return ((KeyCode)0);}

KeySym	XLookupKeysym(event, col)
	    XKeyEvent *event; int col;
	    {return ((KeySym)0);}

int	XLookupString (event, buffer, nbytes, keysym, client_status)
	    XKeyEvent *event; char *buffer; int nbytes; KeySym *keysym;
	    XComposeStatus *client_status; 
	    {return ((int)0);}

	XRebindKeysym (display, keysym, mlist, nm, str, nbytes)
	    Display *display; KeySym keysym; KeySym *mlist; int nm;
	    unsigned char *str; int nbytes;
	    {;}

	XRefreshKeyboardMapping(event)
	    XMappingEvent *event;
	    {;}

int	XUseKeymap(filename)      
	  char *filename;
	  {;}

	XKillClient(display, resource)
	    Display *display; XID resource;
	    {;}

XHostAddress *	XListHosts (display, nhosts, enabled)
	    Display *display; int *nhosts; Bool *enabled; 
	    {return ((XHostAddress *)0);}

Colormap *	XListInstalledColormaps(display, win, n)
	    Display *display;Window win;int *n; 
	    {return ((Colormap *)0);}

Atom *	XListProperties(display, window, n_props)
	    Display *display;Window window;int *n_props; 
	    {return ((Atom *)0);}

char **	XListExtensions(display, nextensions)
	    Display *display;int *nextensions;
	    {return ((char **)0);}

	XFreeExtensionList (list)
	char **list;
	{;}

Font	XLoadFont (display, name)
	    Display *display; char *name;
	    {return ((Font)0);}

Status	XLookupColor (display, cmap, spec, def, scr)
	    Display *display; Colormap cmap; char *spec;
	    XColor *def, *scr;
	    {return ((Status)0);}

	XLowerWindow(display, w) 
	    Display *display;Window w;
	    {;}

	XMapRaised (display, w)     
	   Window w;    Display *display;
	   {;}

	XMapSubwindows(display, win)
	    Display *display; Window win;
	    {;}

	XMapWindow (display, w)  
	    Window w; Display *display;
	    {;}

	XMaskEvent (display, mask, event)
	    Display *display; long mask; XEvent *event; 
	    {;}

	XDisplayKeycodes(display, min_keycode_return, max_keycode_return)
	    Display *display; int *min_keycode_return, *max_keycode_return;
	    {return (0);}

unsigned long	XDisplayMotionBufferSize(display)
	    Display *display;
	    {return ((unsigned long)0);}

long	XMaxRequestSize(display)     
	   Display *display;
	   {return ((long)0);}

char *	XResourceManagerString(display)
	    Display *display;
	    {return ((char *)0);}

VisualID	XVisualIDFromVisual(visual)
	    Visual *visual;
	    {return ((VisualID)0);}

XModifierKeymap *	XDeleteModifiermapEntry(map, keycode, modifier)
	    XModifierKeymap *map; KeyCode keycode; int modifier;
	    {return ((XModifierKeymap *)0);}

	XFreeModifiermap(map)
	    XModifierKeymap *map;
	    {;}

XModifierKeymap *	XGetModifierMapping(display)
	    Display *display;
	    {return ((XModifierKeymap *)0);}

XModifierKeymap *	XInsertModifiermapEntry(map, keycode, modifier)
	    XModifierKeymap *map; KeyCode keycode; int modifier;
	    {return ((XModifierKeymap *)0);}

XModifierKeymap *	XNewModifiermap(keyspermodifier)
	    int keyspermodifier;
	    {return ((XModifierKeymap *)0);}

int	XSetModifierMapping(display, modifier_map)
	    Display *display; XModifierKeymap *modifier_map;
	    {return ((int)0);}

	XMoveWindow (display, w, x, y)
	    Display *display; Window w; int x, y;
	    {;}

	XNextEvent (display, event)
	    Display *display; XEvent *event;
	    {;}

Status	XParseColor (display, cmap, spec, def)
	    Display *display; Colormap cmap; char *spec;
	    XColor *def;
	    {return ((Status)0);}

int	XParseGeometry (string, x, y, width, height)
	    char *string;int *x, *y;unsigned int *width, *height; 
	    {return ((int)0);}

	XPeekEvent (display, event)
	    Display *display; XEvent *event;
	    {;}

	XPeekIfEvent (display, event, predicate, arg)
	    Display *display; XEvent *event; Bool (*predicate)();
	    char *arg;
	    {;}

int	XEventsQueued (display, mode)
	    Display *display; int mode;
	    {return ((int)0);}

int	XPending (display)     
	   Display *display;
	   {return ((int)0);}

	XSetWindowBackgroundPixmap(display, w, pixmap)
	    Display *display; Window w; Pixmap pixmap;
	    {;}

	XSetWindowBorderPixmap(display, w, pixmap)
	    Display *display; Window w; Pixmap pixmap;
	    {;}

Region XPolygonRegion(Pts, Count, rule) int Count; XPoint *Pts;
	    int rule; 
	    {return ((Region)0);}

	XDrawText(display, d, gc, x, y, items, nitems)
	    Display *display; Drawable d; GC gc; int x, y;
	    XTextItem *items;
	    int nitems;
	    {;}

	XDrawText16(display, d, gc, x, y, items, nitems)
	    Display *display; Drawable d; GC gc; int x, y;
	    XTextItem16 *items; int nitems;
	    {;}

	XPutBackEvent (display, event)
	    Display *display; XEvent *event; 
	    {;}

	XPutImage (display, d, gc, image, req_xoffset, req_yoffset, x, 
	    y, req_width, req_height)
	    Display *display; Drawable d; GC gc; XImage *image;
	    int x, y; unsigned int req_width, req_height;
	    int req_xoffset, req_yoffset;
	    {;}

Status	XQueryBestSize(display, class, drawable, width, height, ret_width,
	    ret_height)
	    Display *display; int class; Drawable drawable;
	    unsigned int width, height; unsigned int *ret_width, *ret_height;
	    {return ((Status)0);}

	XQueryColor(display, cmap, def)
	    Display *display; Colormap cmap; XColor *def; 
	    {;}

	XQueryColors(display, cmap, defs, ncolors)
	    Display *display; Colormap cmap; XColor defs[]; int ncolors;
	    {;}

Status	XQueryBestCursor(display, drawable, width, height, ret_width,
	    ret_height)
	    Display *display; Drawable drawable;
	    unsigned int width, height; unsigned int *ret_width, *ret_height;
	    {return ((Status)0);}

Bool	XQueryExtension(display, name, major_opcode, first_event, first_error)
	    Display *display; char *name; int *major_opcode;
	    int *first_event; int *first_error; 
	    {return ((Bool)0);}

	XQueryKeymap(display, keys)
	    Display *display; char keys[32];
	    {;}

Bool	XQueryPointer(display, w, root, child, root_x, root_y, win_x, win_y,
	    mask)
	    Display *display; Window w, *root, *child; 
	    int *root_x, *root_y, *win_x, *win_y; unsigned int *mask;
	    {return ((Bool)0);}

Status	XQueryBestStipple(display, drawable, width, height, ret_width,
	     ret_height)
	    Display *display; Drawable drawable;
	    unsigned int width, height; unsigned int *ret_width, *ret_height;
	    {return ((Status)0);}

	XQueryTextExtents16 (display, fid, string, nchars, dir, font_ascent,
	     font_descent, overall)
	    Display *display; Font fid; XChar2b *string;
	    int nchars; int *dir; int *font_ascent, *font_descent;
	    XCharStruct *overall;
	    {return (0);}

	XQueryTextExtents (display, fid, string, nchars, dir, font_ascent,
	     font_descent, overall)
	    Display *display; Font fid; char *string;
	    int nchars; int *dir; int *font_ascent, *font_descent;
	    XCharStruct *overall;
	    {return (0);}

Status	XQueryBestTile(display, drawable, width, height, ret_width, ret_height)
	    Display *display; Drawable drawable;
	    unsigned int width, height; unsigned int *ret_width, *ret_height;
	    {return ((Status)0);}

Status	XQueryTree (display, w, root, parent, children, nchildren)
	    Display *display; Window w; Window *root; Window *parent; 
	    Window **children; unsigned int *nchildren; 
	    {return ((Status)0);}

	XRaiseWindow (display, w)
	    Display *display; Window w;
	    {;}

int	XReadBitmapFile (display, d, filename, width, height, pixmap,
	     x_hot, y_hot)
	    Display *display; Drawable d; char *filename;
	    unsigned int *width, *height; Pixmap *pixmap; int *x_hot, *y_hot; 
	    {return ((int)0);}

	XRecolorCursor(display, cursor, foreground, background)
	    Display *display; Cursor cursor;
	    XColor *foreground, *background;
	    {;}

	XConfigureWindow(display, w, mask, changes)
	    Display *display; Window w; unsigned int mask;
	    XWindowChanges *changes; 
	    {;}

	XClipBox(r, rect)     
	    Region r;    XRectangle *rect;
	    {;}

	XDestroyRegion(r)     
	    Region r;
	    {;}

int	XEmptyRegion(r)
	    Region r;
	    {return ((int)0);}

int	XEqualRegion(r1, r2)
	    Region r1, r2;
	    {return ((int)0);}

	XIntersectRegion(reg1, reg2, newReg)
	    Region reg1; Region reg2; Region newReg; 
	    {return (0);}

	XOffsetRegion(pRegion, x, y)
	    Region pRegion; int x; int y;
	    {;}

int	XPointInRegion( pRegion, x, y )
	    Region pRegion; int x, y;
	    {return ((int)0);}

int	XRectInRegion(region, rx, ry, rwidth, rheight)
	    Region region; int rx, ry; unsigned int rwidth, rheight;
	    {return ((int)0);}

	XSetRegion( display, gc, r )
	    Display *display; GC gc; Region r;
	    {;}

	XShrinkRegion(r, dx, dy)     
	    Region r;    int dx, dy;
	    {;}

	XSubtractRegion(regM, regS, regD)
	    Region regM; Region regS; Region regD;
	    {return (0);}

	XUnionRectWithRegion(rect, source, dest)
	    XRectangle *rect; Region source, dest;
	    {;}

	XUnionRegion(reg1, reg2, newReg)
	    Region reg1; Region reg2; Region newReg; 
	    {return (0);}

	XXorRegion( sra, srb, dr )     
	  Region sra, srb, dr;
	  {;}

	XReparentWindow(display, w, p, x, y)
	    Display *display; Window w, p; int x, y;
	    {;}

	XRestackWindows (display, windows, n)
	    Display *display; Window *windows; int n; 
	    {;}

	XRotateWindowProperties(display, w, properties, nprops, npositions)
	    Display *display; Window w; Atom properties[];
	    int nprops; int npositions; 
	    {;}

	XSelectInput (display, w, mask)
	    Display *display; Window w; long mask;
	    {;}

Status	XSendEvent(display, w, propagate, event_mask, event)
	    Display *display; Window w; Bool propagate; long event_mask;
	    XEvent *event;
	    {return ((Status)0);}

	XSetBackground (display, gc, background)
	    Display *display;GC gc;unsigned long background; 
	    {;}

	XSetClipRectangles (display, gc, clip_x_origin, clip_y_origin, 
	    rectangles, n, ordering)
	    Display *display; GC gc; int clip_x_origin, clip_y_origin;
	    XRectangle *rectangles; int n; int ordering;
	    {;}

	XSetClipMask (display, gc, mask)
	    Display *display;GC gc;Pixmap mask;
	    {;}

	XSetClipOrigin (display, gc, xorig, yorig)
	    Display *display;GC gc;int xorig, yorig;
	    {;}

	XSetDashes (display, gc, dash_offset, list, n)
	    Display *display; GC gc; int dash_offset; char *list; int n;
	    {;}

	XSetFontPath (display, directories, ndirs)
	    Display *display;char **directories;int ndirs;
	    {;}

	XSetFont (display, gc, font)
	    Display *display;GC gc;Font font;
	    {;}

	XSetForeground (display, gc, foreground)
	    Display *display;GC gc;unsigned long foreground; 
	    {;}

	XSetFunction (display, gc, function)
	    Display *display;GC gc;int function;
	    {;}

	XSetClassHint(display, w, classhint)
	    Display *display; Window w; XClassHint *classhint;
	    {;}

	XSetCommand (display, w, argv, argc)
	    Display *display; Window w; char **argv; int argc;
	    {;}

	XSetIconSizes (display, w, list, count)
	    Display *display; Window w; XIconSize *list; int count; 
	    {;}

	XSetNormalHints (display, w, hints)
	    Display *display; Window w; XSizeHints *hints;
	    {;}

	XSetStandardProperties (display, w, name, icon_string, icon_pixmap,
	     argv, argc, hints)
	    Display *display; Window w; char *name; char *icon_string;
	    Pixmap icon_pixmap; char *argv[]; int argc; XSizeHints *hints; 
	    {;}

	XSetTransientForHint(display, w, propWindow)
	    Display *display; Window w; Window propWindow;
	    {;}

	XSetWMHints (display, w, wmhints)
	    Display *display; Window w; XWMHints *wmhints; 
	    {;}

	XSetZoomHints (display, w, zhints)
	    Display *display; Window w; XSizeHints *zhints;
	    {;}

	XSetInputFocus(display, focus, revert_to, time)
	    Display *display; Window focus; int revert_to; Time time;
	    {;}

	XSetLineAttributes(display, gc, linewidth, linestyle, capstyle,
	    joinstyle)
	    Display *display;GC gc;unsigned int linewidth; int linestyle;
	    int capstyle;int joinstyle;
	    {;}

	XSetPlaneMask (display, gc, planemask)
	    Display *display;GC gc;unsigned long planemask; 
	    {;}

	XChangeKeyboardMapping (display, first_keycode, keysyms_per_keycode,
	     keysyms, nkeycodes)
	    Display *display; int first_keycode; int keysyms_per_keycode;
	    KeySym *keysyms; int nkeycodes; 
	    {;}

int	XSetPointerMapping (display, map, nmaps)
	    Display *display; unsigned char map[]; int nmaps; 
	    {return ((int)0);}

	XSetSelectionOwner(display, selection, owner, time)
	    Display *display;Atom selection;Window owner;Time time;
	    {;}

	XSetScreenSaver(display, timeout, interval, prefer_blank, allow_exp)
	    Display *display;
	    int timeout, interval, prefer_blank, allow_exp;
	    {;}

	XSetState(display, gc, foreground, background, function, planemask)
	    Display *display;GC gc;int function;unsigned long planemask;
	    unsigned long foreground, background;
	    {;}

	XSetStipple (display, gc, stipple)
	    Display *display;GC gc;Pixmap stipple;
	    {;}

	XSetTSOrigin (display, gc, x, y)
	    Display *display;GC gc;int x, y;
	    {;}

	XSetTile (display, gc, tile)
	    Display *display;GC gc;Pixmap tile;
	    {;}

char *	XFetchBuffer (display, nbytes, buffer)
	    Display *display; int *nbytes; int buffer;
	    {return ((char *)0);}

char *	XFetchBytes (display, nbytes)
	    Display *display; int *nbytes;
	    {return ((char *)0);}

	XRotateBuffers (display, rotate)
	    Display *display; int rotate;
	    {;}

	XStoreBuffer (display, bytes, nbytes, buffer)
	    Display *display; char bytes[]; int nbytes;
	    int buffer;
	    {;}

	XStoreBytes (display, bytes, nbytes)
	    Display *display; char bytes[]; int nbytes;
	    {;}

	XStoreColor(display, cmap, def)
	    Display *display;Colormap cmap;XColor *def;
	    {;}

	XStoreColors(display, cmap, defs, ncolors)
	    Display *display;Colormap cmap;XColor defs[];int ncolors;
	    {;}

	XStoreNamedColor(display, cmap, name, pixel, flags)
	    Display *display;Colormap cmap;unsigned long pixel;
	    char *name; int flags; 
	    {;}

	XSetIconName (display, w, icon_name)
	    Display *display; Window w; char *icon_name;
	    {;}

	XStoreName (display, w, name)
	    Display *display; Window w; char *name;
	    {;}

char *	XKeysymToString(ks)     
	    KeySym ks;
	    {return ((char *)0);}

KeySym	XStringToKeysym(s)     
	    char *s;
	    {return ((KeySym)0);}

	XSync (display, discard)
	    Display *display; Bool discard;
	    {;}

	XDrawString(display, d, gc, x, y, string, length)
	    Display *display; Drawable d; GC gc; int x, y; char *string; 
	    int length;
	    {;}


	XDrawString16(display, d, gc, x, y, string, length)
	    Display *display; Drawable d; GC gc; int x, y; XChar2b *string;
	    int length;
	    {;}

	XTextExtents (fs, string, nchars, dir, font_ascent, font_descent,
	     overall)
	    XFontStruct *fs; char *string; int nchars;
	    int *dir, *font_ascent, *font_descent;
	    XCharStruct *overall; 
	    {;}

int	XTextWidth (fs, string, count)
	    XFontStruct *fs; char *string; int count;
	    {return ((int)0);}

	XTextExtents16 (fs, string, nchars, dir, font_ascent, font_descent,
	     overall)
	    XFontStruct *fs; XChar2b *string; int nchars;
	    int *dir, *font_ascent, *font_descent;
	    XCharStruct *overall; 
	    {;}

int	XTextWidth16 (fs, string, count)
	    XFontStruct *fs; XChar2b *string; int count;
	    {return ((int)0);}

int	XTranslateCoordinates(display, src_win, dest_win, src_x, src_y, dst_x,
	     dst_y, child)
	    Display *display; Window src_win, dest_win; int src_x, src_y;
	    int *dst_x, *dst_y; Window *child;
	    {return ((int)0);}

	XUndefineCursor (display,w)
	    Display *display; Window w;
	    {;}

	XUngrabButton(display, button, modifiers, grab_window)
	    Display *display;unsigned int button; unsigned int modifiers;
	    Window grab_window;
	    {;}

	XUngrabKeyboard (display, time)
	    Display *display; Time time;
	    {;}

	XUngrabKey(display, key, modifiers, grab_window)
	    Display *display; int key; unsigned int modifiers;
	    Window grab_window;
	    {;}

	XUngrabPointer(display, time) 
	    Display *display;Time time;{;}

	XUngrabServer (display) 
	    Display *display;{;}

	XUninstallColormap(display, cmap)
	    Display *display;Colormap cmap;
	    {;}

	XUnloadFont(display, font)
	    Display *display; Font font;
	    {;}

	XUnmapSubwindows(display, win) 
	    Display *display; Window win;
	    {;}

	XUnmapWindow (display, w)
	    Display *display; Window w;
	    {;}

XVisualInfo *	XGetVisualInfo(display, visual_info_mask, visual_info_template,
	     nitems)
	    Display *display;long visual_info_mask;
	    XVisualInfo *visual_info_template;int *nitems; 
	    {return ((XVisualInfo *)0);}

Status	XMatchVisualInfo(display, screen, depth, class, visual_info)
	    Display *display; int screen; int depth; int class;
	    XVisualInfo *visual_info;
	    {return ((Status)0);}

	XWarpPointer(display, src_win, dest_win, src_x, src_y, src_width,
	     src_height, dest_x, dest_y)
	    Display *display; Window src_win, dest_win; int src_x, src_y;
	    unsigned int src_width, src_height; int dest_x, dest_y;
	    {;}

	XWindowEvent (display, w, mask, event)
	    Display *display; Window w; long mask; XEvent *event;
	    {;}

Window	XCreateWindow(display, parent, x, y, width, height, borderWidth,
	     depth, class, visual, valuemask, attributes)
	    Display *display; Window parent; int x, y;
	    unsigned int width, height, borderWidth; int depth;
	    unsigned int class; Visual *visual; unsigned long valuemask;
	    XSetWindowAttributes *attributes;
	    {return ((Window)0);}

int	XWriteBitmapFile(display, filename, bitmap, width, height,
	     x_hot, y_hot)
	    Display *display; char *filename; Pixmap bitmap;
	    unsigned int width, height; int x_hot, y_hot;
	    {return ((int)0);}

	XFree (data)  
	    char *data;
	    {;}

XrmDatabase	XrmGetFileDatabase(fileName)
	    char *fileName;
	    {return ((XrmDatabase)0);}

Bool	XrmGetResource(db, name_str, class_str, pType_str, pValue)
	    XrmHashBucket db; XrmString name_str; XrmString class_str;
	    XrmString *pType_str; XrmValuePtr pValue; 
	    {return ((Bool)0);}

XrmDatabase 	XrmGetStringDatabase(data)
	    char *data;
	    {return ((XrmDatabase)0);}

void	XrmInitialize() 
	{;}

void	XrmMergeDatabases(new, into)
	    XrmDatabase new, *into;
	    {;}

void	XrmPutFileDatabase(db, fileName)
	    XrmDatabase db; char *fileName;
	    {;}

void	XrmPutLineResource(pdb, line)
	    XrmDatabase *pdb; char *line;
	    {;}

void	XrmPutResource(pdb, specifier, type, value)
	    XrmDatabase *pdb; char *specifier; char *type; XrmValuePtr value;
	    {;}

void	XrmPutStringResource(pdb, specifier, str)
	    XrmDatabase *pdb; char *specifier; char *str;
	    {;}

Bool	XrmQGetResource(db, names, classes, pType, pValue)
	    XrmHashBucket db; XrmNameList names; XrmClassList classes;
	    XrmRepresentation *pType; XrmValuePtr pValue; 
	    {return ((Bool)0);}

Bool	XrmQGetSearchList(db, names, classes, searchList, listLength)
	    XrmHashBucket db; XrmNameList names; XrmClassList classes;
	    XrmSearchList searchList; int listLength;
	    {return ((Bool)0);}

Bool	XrmQGetSearchResource(searchList, name, class, pType, pVal)
	    XrmSearchList searchList; XrmName name;
	    XrmClass class; XrmRepresentation *pType; XrmValue *pVal; 
	    {return ((Bool)0);}

void	XrmQPutResource(pdb, bindings, quarks, type, value)
	    XrmDatabase *pdb; XrmBindingList bindings; XrmQuarkList quarks;
	    XrmRepresentation type; XrmValuePtr value;
	    {;}

void	XrmQPutStringResource(pdb, bindings, quarks, str)
	    XrmDatabase *pdb; XrmBindingList bindings; XrmQuarkList quarks;
	    char *str;
	    {;}

void	XrmStringToBindingQuarkList(name, bindings, quarks)
	    char *name; XrmBindingList bindings;
	    XrmQuarkList quarks; 
	    {;}

void	XrmStringToQuarkList(name, quarks)
	    char *name; XrmQuarkList quarks; 
	    {;}

int	XDeleteContext(display, window, context)
	    Display *display; Window window; XContext context;
	    {return ((int)0);}

int	XFindContext(display, window, context, data)
            Display *display; Window window; XContext context;caddr_t *data; 
	    {return ((int)0);}

int	XSaveContext(display, window, context, data)
	    Display *display; Window window; XContext context;caddr_t data;
	    {return ((int)0);}

int *	XListDepths (display, scrnum, countp)
	    Display *display; int scrnum; int *countp;
	    {return ((int *)0);}

Status	XGetGCValues (display, gc, valuemask, values_return)
	    Display *display; GC gc; unsigned long valuemask; 
	    XGCValues *values_return;
	    {return ((Status)0);}

Status	XGetWMNormalHints (display, w, hints, supplied)
	    Display *display; Window w; XSizeHints *hints; long *supplied;
	    {return ((Status)0);}

Status	XGetRGBColormaps (display, w, stdcmap, count, property)
	    Display *display; Window w; XStandardColormap **stdcmap; int *count;
	    Atom property; 
	    {return ((Status)0);}

Status	XGetWMClientMachine (display, w, text_prop)
	    Display *display; Window w; XTextProperty *text_prop;
	    {return ((Status)0);}

Status	XGetWMIconName (display, w, tp)
	    Display *display; Window w; XTextProperty *tp;
	    {return ((Status)0);}

Status	XGetWMName (display, w, tp)
	    Display *display; Window w; XTextProperty *tp;
	    {return ((Status)0);}

Status	XIconifyWindow (display, w, screen)
	    Display *display; Window w; int screen;
	    {return ((Status)0);}

void	XrmParseCommand(pdb, options, num_options, prefix, argc, argv)
	    XrmDatabase *pdb;  XrmOptionDescList options; int num_options;
	    char *prefix; int *argc; char **argv; 
	    {;}

XPixmapFormatValues *	XListPixmapFormats (display, count)
	    Display *display; int *count; 
	    {return ((XPixmapFormatValues *)0);}

XClassHint	*XAllocClassHint ()
	    {return ((XClassHint *)0);}

XIconSize *	XAllocIconSize ()
	    {return ((XIconSize *)0);}

XSizeHints *	XAllocSizeHints ()
	    {return ((XSizeHints *)0);}

XStandardColormap *	XAllocStandardColormap ()
	    {return ((XStandardColormap *)0);}

XWMHints *	XAllocWMHints ()
	    {return ((XWMHints *)0);}

char *	Xpermalloc(length)
	    unsigned int length;
	    {return ((char *)0);}

XrmString	XrmQuarkToString(quark)
	    XrmQuark quark;
	    {return ((XrmString)0);}

XrmQuark	XrmStringToQuark(name)
	     XrmString name;
	    {return ((XrmQuark)0);}

XrmQuark	XrmUniqueQuark()
	    {return ((XrmQuark)0);}

void	XSetWMNormalHints (display, w, hints)
	    Display *display; Window w; XSizeHints *hints;
	    {;}

void	XSetRGBColormaps (display, w, cmaps, count, property)
	    Display *display; Window w; XStandardColormap *cmaps; int count;
	    Atom property; 
	    {;}

Status	XSetWMColormapWindows (display, w, windows, count)
	    Display *display; Window w; Window *windows; int count;
	    {return ((Status)0);}

void	XSetWMProperties (display, w, windowName, iconName, argv, argc,
	    sizeHints, wmHints, classHints)
	    Display *display; Window w; XTextProperty *windowName;
	    XTextProperty *iconName; char **argv; int argc;
	    XSizeHints *sizeHints; XWMHints *wmHints; XClassHint *classHints; 
	    {;}

Status	XSetWMProtocols (display, w, protocols, count)
	    Display *display; Window w; Atom *protocols; int count;
	    {return ((Status)0);}

Status	XStringListToTextProperty (argv, argc, textprop)
	    char **argv; int argc; XTextProperty *textprop;
	    {return ((Status)0);}

void	XFreeStringList (list)     
	    char **list;
	    {;}

Status	XTextPropertyToStringList (tp, list_return, count_return)
	    XTextProperty *tp; char ***list_return; int *count_return;
	    {return ((Status)0);}

Status	XWithdrawWindow (display, w, screen)
	    Display *display; Window w; int screen;
	    {return ((Status)0);}

void	XSetAuthorization (name, namelen, data, datalen)
	    int namelen, datalen; char *name, *data;             
	    {;}

void	XSetStandardColormap(display, w, cmap, property)
	    Display *display; Window w; XStandardColormap *cmap; Atom property; 
	    {;}

void	XrmDestroyDatabase(rdb)
	    XrmDatabase   rdb;
	    {;}

Status	XReconfigureWMWindow (display, w, screen, mask, changes)
	    Display *display; Window w; int screen; unsigned int mask;
	    XWindowChanges *changes;
	    {return ((Status)0);}

void 	XSetTextProperty (display, w, tp, property)
	    Display *display; Window w; Atom property; XTextProperty *tp;
	    {;}

void 	XSetWMName (display, w, tp)
	    Display *display; Window w; XTextProperty *tp;
	    {;}

void 	XSetWMIconName (display, w, tp)
	    Display *display; Window w; XTextProperty *tp;
	    {;}

void 	XSetWMClientMachine (display, w, text_prop)
	    Display *display; Window w; XTextProperty *text_prop;
	    {;}

Status XGetTextProperty (display, window, tp, property)
	    Display *display; Window window; XTextProperty *tp; Atom property;
	    {return ((Status)0);}

void	XSetWMSizeHints (display, w, hints, prop)
	    Display *display; Window w; XSizeHints *hints; Atom prop;
	    {;}

Status	XGetWMSizeHints (display, w, hints, supplied, property)
	    Display *display; Window w; XSizeHints *hints; long *supplied;
	    Atom property;
	    {return ((Status)0);}

Status	XGetWMProtocols (display, w, protocols, countReturn)
	    Display *display; Window w; Atom **protocols; int *countReturn;
	    {return ((Status)0);}

Status	XGetWMColormapWindows (display, w, colormapWindows, countReturn)
	    Display *display; Window w; Window **colormapWindows;
	    int *countReturn;
	    {return ((Status)0);}

int	XWMGeometry (display, screen, user_geom, def_geom, bwidth, hints,
	    x_return, y_return, width_return, height_return, gravity_return)
	    Display *display; int screen; char *user_geom; char *def_geom;
	    unsigned int bwidth; XSizeHints *hints; int *x_return, *y_return;
	    int *width_return, *height_return; int *gravity_return; 
	    {return (0);}

