Attachment 413 Details for Bug 799 – patch for 2004-06-24-oldcvs_trunk

[patch] patch for 2004-06-24-oldcvs_trunk

patch.gudiff (text/plain), 472.83 KB, created by Roland Mainz on 2004-06-23 21:17:01 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Roland Mainz

Created: 2004-06-23 21:17:01 UTC

Size: 472.83 KB

patch

obsolete

>Index: xc/programs/x11perf/Imakefile
>===================================================================
>RCS file: xc/programs/x11perf/Imakefile
>diff -N xc/programs/x11perf/Imakefile
>--- xc/programs/x11perf/Imakefile	28 May 2002 01:48:43 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,39 +0,0 @@
>-XCOMM $Xorg: Imakefile,v 1.3 2000/08/17 19:54:08 cpqbld Exp $
>-#ifndef X11perfcompLib
>-#define X11perfcompLib $(LIBDIR)/x11perfcomp
>-#endif
>-
>-#if HasShm
>-        SHMDEFS = -DMITSHM
>-#endif
>-        DEFINES = $(SIGNAL_DEFINES) $(SHMDEFS)
>-        PERFLIB = X11perfcompLib
>-        HEADERS = x11perf.h bitmaps.h
>-           SRCS = x11perf.c bitmaps.c do_tests.c \
>-		  do_simple.c do_rects.c do_valgc.c \
>-		  do_lines.c do_segs.c \
>-		  do_dots.c do_windows.c do_movewin.c do_text.c \
>-		  do_blt.c do_arcs.c \
>-		  do_tris.c do_complex.c do_traps.c
>-           OBJS = x11perf.o bitmaps.o do_tests.o \
>-		  do_simple.o do_rects.o do_valgc.o \
>-		  do_lines.o do_segs.o \
>-		  do_dots.o do_windows.o do_movewin.o do_text.o \
>-		  do_blt.o do_arcs.o \
>-		  do_tris.o do_complex.o do_traps.o
>-LOCAL_LIBRARIES = $(XMULIB) $(XLIB)
>-        DEPLIBS = $(DEPXMULIB) $(DEPXLIB)
>-  SYS_LIBRARIES = MathLibrary
>-
>-ComplexProgramTarget(x11perf)
>-
>-all:: x11perfcomp
>-
>-CppScriptTarget(x11perfcomp,x11pcomp.cpp,-DLIBPATH=$(PERFLIB),$(ICONFIGFILE))
>-
>-InstallNamedProg(x11perfcomp,x11perfcomp,$(BINDIR))
>-InstallNamedProg(fillblnk.sh,fillblnk,$(PERFLIB))
>-InstallNamedProg(perfboth.sh,perfboth,$(PERFLIB))
>-InstallNamedProg(perfratio.sh,perfratio,$(PERFLIB))
>-InstallNamedProg(Xmark.sh,Xmark,$(BINDIR))
>-InstallManPageLong(x11pcomp,$(MANDIR),x11perfcomp)
>Index: xc/programs/x11perf/Xmark.sh
>===================================================================
>RCS file: xc/programs/x11perf/Xmark.sh
>diff -N xc/programs/x11perf/Xmark.sh
>--- xc/programs/x11perf/Xmark.sh	28 May 2002 01:48:43 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,635 +0,0 @@
>-#! /bin/sh
>-#$Xorg: Xmark.sh,v 1.3 2000/08/17 19:54:08 cpqbld Exp $
>-#XPC Header: Xmark,v 1.15 93/04/12 10:10:07 hmgr Exp
>-#
>-############################################################
>-# Xmark version XPC Revision: 1.15
>-#
>-# Usage: Xmark datafile
>-#
>-############################################################
>-# CHANGE HISTORY:
>-#
>-# X11perfcompDR  --  Creates a Digital Review compatible breakdown of 
>-# x11perf v1.2 results as described in "Take Your Pick Of Graphics"
>-# by John Montgomery, Digital Review, May 7th, 1990, Page 44. 
>-# 8/30/90  v1.0 program created by Lonnie Mandigo 
>-# 1/18/91  Modification by  Lonnie Mandigo
>-#	   Fixed a bug to include UCIRC in data.
>-# 2/5/91   Modification by  Lonnie Mandigo
>-#          Now removes sum.tmp file when finished.
>-# 3/18/91  v1.01 Increased resolution to handle zero ratios.
>-#          Minor aesethic cleanups and better error handling.
>-#          Lonnie Mandigo and Jason Levitt (jason@cs.utexas.edu)
>-# 3/4/93   Converted to Xmark by Bob Kuseski
>-#          to produce a single number representing the ratio between 
>-#	   the xpc weighted averages of the output from x11perf Rev 1.3
>-#	   for the server under test and a SparcStation 1
>-# 3/10/93  Changed to produce THREE output numbers and added bounds
>-#	   checking of input data.
>-# 3/15/93  Removed usage of '-F' in grep for compatibility reasons
>-# 3/16/93  Corrected usage of substr() and used two greps versus fgrep
>-# 4/12/93  Eliminated use of functions and \n in echo
>-#
>-############################################################
>-# Copyright (c) 1993 by Hewlett-Packard Company
>-#
>-# Permission to use, copy, modify, and  distribute  this  software and its
>-# documentation  for  any  purpose  and  without  fee is  hereby  granted,
>-# provided that the above  copyright  notice appear in all copies and that
>-# both  the  copyright  notice  and  this  permission   notice  appear  in
>-# supporting  documentation, and that the name of  Hewlett-Packard  not be
>-# used in  advertising  or publicity  pertaining  to  distribution  of the
>-# software without specific, written prior permission.
>-#
>-############################################################
>-# Instructions:
>-# 
>-# Usage: Xmark datafile
>-#
>-# where: 'datafile' is created by running x11perf Rev 1.3
>-# with the flags below:
>-#
>-#      x11perf -display mysystem:0.0 -v1.3 -rop GXcopy GXxor -all > datafile
>-#   or
>-#      x11perf -display mysystem:0.0 -v1.3 -rop GXcopy -all > datafile
>-#      x11perf -display mysystem:0.0 -v1.3 -rop GXxor -all >> datafile
>-#   or
>-#      x11perf -display mysystem:0.0 -v1.3 -rop GXxor -all > datafile
>-#      x11perf -display mysystem:0.0 -v1.3 -rop GXcopy -all >> datafile
>-#
>-# Xmark summarizes the results relative to the data contained in
>-# the datafile.  Xmark writes to standard out, so if you want to
>-# capture the output in a file, use:
>-# 
>-#   Xmark datafile > output.comp
>-#
>-# The 'output.comp' contains THREE numbers:
>-#	    - Weighted x11perf number of the server under test
>-#	    - Weighted x11perf number of the SparcStation 1
>-#	    - Xmark = the ratio of the above two numbers
>-#
>-# Note the SparcStation 1 number comes from a:
>-#   X11R5 Xsun
>-#   Standard with SunOS 4.1.2
>-#   SunOs 4.1.2
>-#   CG3 dumb Color Frame Buffer
>-#
>-############################################################
>-############################################################
>-
>-# Cleanup on interrupt
>-trap \
>-"echo Interrupt: removing temporary files. >& 2 ;rm -f temp.$$ rates.$$ awkfile.$$; exit 1" 1 2 3 9 15
>-
>-# Must have only one file specified
>-if [ "$#" -ne 1 ]
>-then
>-    echo "Usage: $0 datafile" >& 2
>-    exit 1
>-fi
>-
>-# Must be an ordinary file
>-if [ ! -f "$1" ]
>-then
>-    echo "Error: data file does not exist or is not ordinary." >& 2
>-    exit 1
>-fi
>-
>-# See if the date file has the correct number of results.
>-LC1=`grep trep "$1" | wc -l`
>-LC2=441		# Number of test without Shared Memory Transport
>-LC3=447		# Number of test with Shared Memory Transport
>-
>-if [ "$LC1" -ne "$LC2" ] && [ "$LC1" -ne "$LC3" ]
>-then
>-    echo "WARNING: datafile contains $LC1, not "$LC2" or "$LC3" 'trep' results;" >& 2
>-    if [ "$LC1" -gt "$LC2" ]
>-    then
>-	echo "extra results are probably OK." >& 2
>-	echo ""
>-    fi
>-fi
>- 
>-DATA=$1
>-
>-grep trep $DATA		> temp.$$
>-grep server $DATA	>> temp.$$
>-
>-# convert the averages to standard form.
>-
>-cat > awkfile.$$ <<'EOS'
>-    BEGIN {
>-	weight["10x10 rectangle"] = 37;
>-	weight["Scroll 500x500 pixels"] = 33;
>-	weight["100x100 rectangle"] = 32;
>-	weight["10-pixel line segment"] = 31;
>-	weight["10-pixel line"] = 30;
>-	weight["PutImage 100x100 square"] = 30;
>-	weight["Scroll 100x100 pixels"] = 29;
>-	weight["PutImage 500x500 square"] = 29;
>-	weight["500x500 rectangle"] = 29;
>-	weight["100-pixel line"] = 28;
>-	weight["Char in 60-char line (9x15)"] = 28;
>-	weight["Char in 80-char image line (6x13)"] = 28;
>-	weight["Char in 80-char line (6x13)"] = 27;
>-	weight["Char in 80-char image line (TR 10)"] = 27;
>-	weight["100-pixel line segment"] = 27;
>-	weight["Char in 80-char line (TR 10)"] = 27;
>-	weight["Char in 60-char image line (9x15)"] = 26;
>-	weight["Copy 100x100 from pixmap to window"] = 26;
>-	weight["Copy 500x500 from pixmap to window"] = 26;
>-	weight["Char in 70-char line (8x13)"] = 24;
>-	weight["500-pixel line"] = 24;
>-	weight["Char in 20/40/20 line (6x13, TR 10)"] = 23;
>-	weight["Char in 70-char image line (8x13)"] = 23;
>-	weight["Change graphics context"] = 23;
>-	weight["Copy 100x100 from window to window"] = 23;
>-	weight["10-pixel horizontal line segment"] = 23;
>-	weight["10-pixel vertical line segment"] = 23;
>-	weight["Copy 500x500 from window to window"] = 22;
>-	weight["Char in 30-char line (TR 24)"] = 22;
>-	weight["Char16 in 40-char line (k14)"] = 22;
>-	weight["500-pixel line segment"] = 22;
>-	weight["Char in 30-char image line (TR 24)"] = 22;
>-	weight["100-pixel horizontal line segment"] = 22;
>-	weight["100-pixel vertical line segment"] = 22;
>-	weight["Scroll 10x10 pixels"] = 21;
>-	weight["Char16 in 40-char image line (k14)"] = 21;
>-	weight["GetImage 500x500 square"] = 21;
>-	weight["PutImage 10x10 square"] = 20;
>-	weight["GetImage 100x100 square"] = 20;
>-	weight["Move window (4 kids)"] = 20;
>-	weight["Copy 10x10 from pixmap to window"] = 20;
>-	weight["100x100 4x4 tiled rectangle"] = 20;
>-	weight["Copy 100x100 from window to pixmap"] = 19;
>-	weight["Hide/expose window via popup (4 kids)"] = 19;
>-	weight["Copy 500x500 from window to pixmap"] = 19;
>-	weight["500-pixel horizontal line segment"] = 19;
>-	weight["500-pixel vertical line segment"] = 19;
>-	weight["Fill 10x10 equivalent triangle"] = 19;
>-	weight["Char16 in 23-char line (k24)"] = 19;
>-	weight["1x1 rectangle"] = 19;
>-	weight["Char16 in 7/14/7 line (k14, k24)"] = 18;
>-	weight["10x10 4x4 tiled rectangle"] = 18;
>-	weight["100-pixel line segment (1 kid)"] = 18;
>-	weight["100x100 rectangle outline"] = 18;
>-	weight["Move window via parent (4 kids)"] = 18;
>-	weight["GetAtomName"] = 18;
>-	weight["GetProperty"] = 18;
>-	weight["Char16 in 23-char image line (k24)"] = 18;
>-	weight["100-pixel line segment (3 kids)"] = 17;
>-	weight["Resize window (4 kids)"] = 17;
>-	weight["Map window via parent (4 kids)"] = 17;
>-	weight["Copy 100x100 from pixmap to pixmap"] = 17;
>-	weight["Unmap window via parent (4 kids)"] = 17;
>-	weight["100-pixel line segment (2 kids)"] = 17;
>-	weight["10-pixel solid circle"] = 17;
>-	weight["1-pixel line"] = 17;
>-	weight["Move window (16 kids)"] = 16;
>-	weight["Fill 100x100 equivalent triangle"] = 16;
>-	weight["Hide/expose window via popup (16 kids)"] = 16;
>-	weight["Move window via parent (16 kids)"] = 16;
>-	weight["10x10 rectangle outline"] = 16;
>-	weight["Destroy window via parent (4 kids)"] = 16;
>-	weight["Create unmapped window (4 kids)"] = 16;
>-	weight["Copy 10x10 from window to window"] = 16;
>-	weight["Copy 100x100 1-bit deep plane"] = 16;
>-	weight["10-pixel circle"] = 16;
>-	weight["100x100 opaque stippled rectangle"] = 16;
>-	weight["500x500 4x4 tiled rectangle"] = 16;
>-	weight["100x100 stippled rectangle"] = 16;
>-	weight["Copy 500x500 from pixmap to pixmap"] = 16;
>-	weight["Create and map subwindows (16 kids)"] = 16;
>-	weight["10x10 stippled rectangle"] = 16;
>-	weight["Resize window (16 kids)"] = 16;
>-	weight["Map window via parent (16 kids)"] = 15;
>-	weight["100-pixel solid circle"] = 15;
>-	weight["Copy 500x500 1-bit deep plane"] = 15;
>-	weight["500x500 rectangle outline"] = 15;
>-	weight["Create and map subwindows (4 kids)"] = 15;
>-	weight["Destroy window via parent (16 kids)"] = 15;
>-	weight["10x1 wide horizontal line segment"] = 15;
>-	weight["10x1 wide vertical line segment"] = 15;
>-	weight["100x100 161x145 tiled rectangle"] = 15;
>-	weight["1-pixel line segment"] = 15;
>-	weight["Unmap window via parent (16 kids)"] = 15;
>-	weight["Fill 100x100 trapezoid"] = 14;
>-	weight["100-pixel circle"] = 14;
>-	weight["10x10 opaque stippled rectangle"] = 14;
>-	weight["100-pixel dashed line"] = 14;
>-	weight["500x500 161x145 tiled rectangle"] = 14;
>-	weight["Copy 10x10 from window to pixmap"] = 14;
>-	weight["100x10 wide horizontal line segment"] = 14;
>-	weight["100x10 wide vertical line segment"] = 14;
>-	weight["100x100 wide rectangle outline"] = 14;
>-	weight["100x100 216x208 tiled rectangle"] = 14;
>-	weight["Dot"] = 14;
>-	weight["10x10 161x145 tiled rectangle"] = 14;
>-	weight["Fill 100x100 equivalent complex polygons"] = 14;
>-	weight["Move window (50 kids)"] = 13;
>-	weight["Move window via parent (50 kids)"] = 13;
>-	weight["Circulate window (16 kids)"] = 13;
>-	weight["100-pixel dashed segment"] = 13;
>-	weight["Create and map subwindows (50 kids)"] = 13;
>-	weight["Create and map subwindows (25 kids)"] = 13;
>-	weight["10x10 wide rectangle outline"] = 13;
>-	weight["500x500 216x208 tiled rectangle"] = 13;
>-	weight["Hide/expose window via popup (25 kids)"] = 13;
>-	weight["Create and map subwindows (100 kids)"] = 13;
>-	weight["Map window via parent (50 kids)"] = 13;
>-	weight["Fill 10x10 trapezoid"] = 13;
>-	weight["100x10 wide line"] = 13;
>-	weight["10x10 216x208 tiled rectangle"] = 13;
>-	weight["10-pixel dashed line"] = 13;
>-	weight["Map window via parent (100 kids)"] = 13;
>-	weight["Copy 10x10 from pixmap to pixmap"] = 13;
>-	weight["Map window via parent (25 kids)"] = 13;
>-	weight["Create unmapped window (25 kids)"] = 13;
>-	weight["Move window (25 kids)"] = 13;
>-	weight["Circulate window (4 kids)"] = 12;
>-	weight["Move window via parent (25 kids)"] = 12;
>-	weight["Create unmapped window (16 kids)"] = 12;
>-	weight["Create and map subwindows (75 kids)"] = 12;
>-	weight["500x500 opaque stippled rectangle"] = 12;
>-	weight["Hide/expose window via popup (100 kids)"] = 12;
>-	weight["Create and map subwindows (200 kids)"] = 12;
>-	weight["Hide/expose window via popup (50 kids)"] = 12;
>-	weight["500x50 wide horizontal line segment"] = 12;
>-	weight["500x50 wide vertical line segment"] = 12;
>-	weight["100x100 161x145 opaque stippled rectangle"] = 12;
>-	weight["Resize window (25 kids)"] = 12;
>-	weight["Map window via parent (200 kids)"] = 12;
>-	weight["10x10 161x145 opaque stippled rectangle"] = 12;
>-	weight["X protocol NoOperation"] = 12;
>-	weight["10-pixel dashed segment"] = 12;
>-	weight["Resize unmapped window (16 kids)"] = 12;
>-	weight["Create unmapped window (100 kids)"] = 12;
>-	weight["Fill 10x10 equivalent complex polygon"] = 12;
>-	weight["Map window via parent (75 kids)"] = 12;
>-	weight["100x100 161x145 stippled rectangle"] = 12;
>-	weight["Moved unmapped window (16 kids)"] = 12;
>-	weight["Copy 10x10 1-bit deep plane"] = 12;
>-	weight["Unmap window via parent (50 kids)"] = 12;
>-	weight["GetImage 10x10 square"] = 12;
>-	weight["Fill 100x100 tiled trapezoid"] = 12;
>-	weight["500x500 wide rectangle outline"] = 12;
>-	weight["Fill 100x100 stippled trapezoid"] = 12;
>-	weight["500x500 stippled rectangle"] = 12;
>-	weight["Moved unmapped window (4 kids)"] = 12;
>-	weight["10x10 161x145 stippled rectangle"] = 12;
>-	weight["Unmap window via parent (25 kids)"] = 12;
>-	weight["500-pixel solid circle"] = 12;
>-	weight["Create unmapped window (50 kids)"] = 12;
>-	weight["Destroy window via parent (25 kids)"] = 11;
>-	weight["Resize window (200 kids)"] = 11;
>-	weight["100-pixel filled ellipse"] = 11;
>-	weight["Hide/expose window via popup (200 kids)"] = 11;
>-	weight["Unmap window via parent (100 kids)"] = 11;
>-	weight["Circulate window (25 kids)"] = 11;
>-	weight["Resize window (50 kids)"] = 11;
>-	weight["Hide/expose window via popup (75 kids)"] = 11;
>-	weight["Destroy window via parent (100 kids)"] = 11;
>-	weight["Destroy window via parent (50 kids)"] = 11;
>-	weight["Create unmapped window (200 kids)"] = 11;
>-	weight["Fill 100x100 opaque stippled trapezoid"] = 11;
>-	weight["Move window via parent (75 kids)"] = 11;
>-	weight["500-pixel filled ellipse"] = 11;
>-	weight["Resize unmapped window (4 kids)"] = 11;
>-	weight["Move window via parent (200 kids)"] = 11;
>-	weight["Move window (75 kids)"] = 11;
>-	weight["Fill 10x10 tiled trapezoid"] = 11;
>-	weight["Fill 100x100 161x145 stippled trapezoid"] = 11;
>-	weight["Move window (200 kids)"] = 11;
>-	weight["Fill 10x10 stippled trapezoid"] = 11;
>-	weight["Create unmapped window (75 kids)"] = 11;
>-	weight["100-pixel fill chord partial circle"] = 10;
>-	weight["Circulate Unmapped window (16 kids)"] = 10;
>-	weight["Circulate window (50 kids)"] = 10;
>-	weight["Move window (100 kids)"] = 10;
>-	weight["Circulate window (100 kids)"] = 10;
>-	weight["Move window via parent (100 kids)"] = 10;
>-	weight["500x50 wide line"] = 10;
>-	weight["500-pixel circle"] = 10;
>-	weight["100-pixel double-dashed line"] = 10;
>-	weight["Unmap window via parent (200 kids)"] = 10;
>-	weight["Moved unmapped window (50 kids)"] = 10;
>-	weight["10-pixel filled ellipse"] = 10;
>-	weight["Resize window (75 kids)"] = 10;
>-	weight["Fill 100x100 161x145 tiled trapezoid"] = 10;
>-	weight["500x500 161x145 opaque stippled rectangle"] = 10;
>-	weight["Fill 100x100 161x145 opaque stippled trapezoid"] = 10;
>-	weight["Unmap window via parent (75 kids)"] = 10;
>-	weight["Resize unmapped window (25 kids)"] = 10;
>-	weight["100-pixel ellipse"] = 10;
>-	weight["Destroy window via parent (75 kids)"] = 10;
>-	weight["Fill 1x1 equivalent triangle"] = 10;
>-	weight["500-pixel ellipse"] = 10;
>-	weight["Fill 10x10 opaque stippled trapezoid"] = 10;
>-	weight["Resize window (100 kids)"] = 10;
>-	weight["500x500 161x145 stippled rectangle"] = 10;
>-	weight["Destroy window via parent (200 kids)"] = 10;
>-	weight["100-pixel fill slice partial circle"] = 10;
>-	weight["Fill 100x100 216x208 tiled trapezoid"] = 9;
>-	weight["100-pixel wide circle"] = 9;
>-	weight["Moved unmapped window (25 kids)"] = 9;
>-	weight["10x1 wide line"] = 9;
>-	weight["Resize unmapped window (100 kids)"] = 9;
>-	weight["100-pixel double-dashed segment"] = 9;
>-	weight["10-pixel fill chord partial circle"] = 9;
>-	weight["Circulate window (75 kids)"] = 9;
>-	weight["100-pixel partial circle"] = 9;
>-	weight["Circulate window (200 kids)"] = 9;
>-	weight["Fill 10x10 161x145 stippled trapezoid"] = 9;
>-	weight["Circulate Unmapped window (4 kids)"] = 9;
>-	weight["100-pixel dashed circle"] = 9;
>-	weight["Circulate Unmapped window (25 kids)"] = 9;
>-	weight["10-pixel ellipse"] = 9;
>-	weight["Resize unmapped window (50 kids)"] = 9;
>-	weight["100-pixel partial ellipse"] = 9;
>-	weight["Fill 10x10 161x145 tiled trapezoid"] = 8;
>-	weight["100x10 wide dashed line"] = 8;
>-	weight["10-pixel partial circle"] = 8;
>-	weight["100-pixel wide ellipse"] = 8;
>-	weight["Fill 10x10 161x145 opaque stippled trapezoid"] = 8;
>-	weight["100-pixel wide partial circle"] = 8;
>-	weight["Moved unmapped window (75 kids)"] = 8;
>-	weight["Resize unmapped window (75 kids)"] = 8;
>-	weight["Circulate Unmapped window (100 kids)"] = 8;
>-	weight["100-pixel fill slice partial ellipse"] = 8;
>-	weight["100x10 wide double-dashed line"] = 8;
>-	weight["10-pixel fill slice partial circle"] = 8;
>-	weight["100-pixel dashed ellipse"] = 8;
>-	weight["100-pixel fill chord partial ellipse"] = 8;
>-	weight["100-pixel wide dashed circle"] = 8;
>-	weight["100-pixel double-dashed circle"] = 8;
>-	weight["Fill 10x10 216x208 tiled trapezoid"] = 7;
>-	weight["Moved unmapped window (100 kids)"] = 7;
>-	weight["10-pixel wide circle"] = 7;
>-	weight["Moved unmapped window (200 kids)"] = 7;
>-	weight["Resize unmapped window (200 kids)"] = 7;
>-	weight["Circulate Unmapped window (50 kids)"] = 7;
>-	weight["1-pixel circle"] = 7;
>-	weight["10-pixel partial ellipse"] = 7;
>-	weight["500-pixel wide circle"] = 7;
>-	weight["500-pixel wide ellipse"] = 7;
>-	weight["100-pixel wide partial ellipse"] = 7;
>-	weight["Circulate Unmapped window (75 kids)"] = 7;
>-	weight["100-pixel wide dashed ellipse"] = 7;
>-	weight["100-pixel double-dashed ellipse"] = 7;
>-	weight["10-pixel wide ellipse"] = 6;
>-	weight["10-pixel wide partial circle"] = 6;
>-	weight["1-pixel solid circle"] = 6;
>-	weight["100-pixel wide double-dashed circle"] = 6;
>-	weight["Circulate Unmapped window (200 kids)"] = 6;
>-	weight["1x1 4x4 tiled rectangle"] = 6;
>-	weight["10-pixel wide partial ellipse"] = 6;
>-	weight["10-pixel fill chord partial ellipse"] = 6;
>-	weight["10-pixel fill slice partial ellipse"] = 6;
>-	weight["100-pixel wide double-dashed ellipse"] = 5;
>-	weight["1x1 161x145 tiled rectangle"] = 5;
>-	weight["1x1 216x208 tiled rectangle"] = 5;
>-	weight["1x1 stippled rectangle"] = 5;
>-	weight["1x1 opaque stippled rectangle"] = 4;
>-	weight["1x1 161x145 opaque stippled rectangle"] = 4;
>-	weight["1x1 161x145 stippled rectangle"] = 4;
>-	weight["ShmPutImage 10x10 square"] = 0;
>-	weight["ShmPutImage 100x100 square"] = 0;
>-	weight["ShmPutImage 500x500 square"] = 0;
>-	weight["(xor) 100-pixel line"] = 16;
>-	weight["(xor) 10-pixel line segment"] = 14;
>-	weight["(xor) 10-pixel line"] = 13;
>-	weight["(xor) 100-pixel line segment"] = 13;
>-	weight["(xor) 500-pixel line segment"] = 13;
>-	weight["(xor) 500-pixel line"] = 12;
>-	weight["(xor) 10x10 rectangle"] = 12;
>-	weight["(xor) 100x100 rectangle"] = 12;
>-	weight["(xor) 100-pixel vertical line segment"] = 10;
>-	weight["(xor) 100x100 rectangle outline"] = 10;
>-	weight["(xor) 100-pixel horizontal line segment"] = 10;
>-	weight["(xor) 10-pixel vertical line segment"] = 10;
>-	weight["(xor) 100-pixel line segment (2 kids)"] = 10;
>-	weight["(xor) 10-pixel horizontal line segment"] = 10;
>-	weight["(xor) 100-pixel line segment (1 kid)"] = 9;
>-	weight["(xor) Char in 80-char line (6x13)"] = 9;
>-	weight["(xor) 500-pixel vertical line segment"] = 9;
>-	weight["(xor) Copy 100x100 from pixmap to window"] = 9;
>-	weight["(xor) 10x10 rectangle outline"] = 9;
>-	weight["(xor) 500-pixel horizontal line segment"] = 9;
>-	weight["(xor) 100-pixel line segment (3 kids)"] = 9;
>-	weight["(xor) PutImage 100x100 square"] = 9;
>-	weight["(xor) 500x500 rectangle outline"] = 9;
>-	weight["(xor) Char in 80-char line (TR 10)"] = 9;
>-	weight["(xor) 500x500 rectangle"] = 9;
>-	weight["(xor) Copy 500x500 from pixmap to window"] = 8;
>-	weight["(xor) Char in 20/40/20 line (6x13, TR 10)"] = 8;
>-	weight["(xor) 100-pixel dashed line"] = 8;
>-	weight["(xor) Copy 100x100 1-bit deep plane"] = 8;
>-	weight["(xor) Char in 60-char line (9x15)"] = 8;
>-	weight["(xor) Char16 in 40-char line (k14)"] = 7;
>-	weight["(xor) Fill 10x10 equivalent triangle"] = 7;
>-	weight["(xor) PutImage 500x500 square"] = 7;
>-	weight["(xor) Copy 100x100 from window to window"] = 7;
>-	weight["(xor) 100-pixel dashed segment"] = 7;
>-	weight["(xor) 100x100 wide rectangle outline"] = 6;
>-	weight["(xor) Char16 in 7/14/7 line (k14, k24)"] = 6;
>-	weight["(xor) Fill 100x100 trapezoid"] = 6;
>-	weight["(xor) 100-pixel solid circle"] = 6;
>-	weight["(xor) 10-pixel solid circle"] = 6;
>-	weight["(xor) 1-pixel line segment"] = 6;
>-	weight["(xor) 1-pixel line"] = 6;
>-	weight["(xor) 10x1 wide horizontal line segment"] = 6;
>-	weight["(xor) 10x1 wide vertical line segment"] = 6;
>-	weight["(xor) Copy 100x100 from pixmap to pixmap"] = 6;
>-	weight["(xor) 10-pixel dashed line"] = 6;
>-	weight["(xor) Char in 30-char line (TR 24)"] = 6;
>-	weight["(xor) Fill 100x100 equivalent triangle"] = 6;
>-	weight["(xor) Copy 10x10 from pixmap to window"] = 6;
>-	weight["(xor) Fill 10x10 trapezoid"] = 6;
>-	weight["(xor) Char in 70-char line (8x13)"] = 6;
>-	weight["(xor) 100-pixel circle"] = 6;
>-	weight["(xor) Copy 100x100 from window to pixmap"] = 6;
>-	weight["(xor) 10-pixel dashed segment"] = 5;
>-	weight["(xor) 10-pixel circle"] = 5;
>-	weight["(xor) 10x10 wide rectangle outline"] = 5;
>-	weight["(xor) 100x100 stippled rectangle"] = 5;
>-	weight["(xor) 100-pixel filled ellipse"] = 5;
>-	weight["(xor) 10x10 4x4 tiled rectangle"] = 5;
>-	weight["(xor) PutImage 10x10 square"] = 5;
>-	weight["(xor) Copy 500x500 from window to window"] = 5;
>-	weight["(xor) 500x500 wide rectangle outline"] = 5;
>-	weight["(xor) 10x10 stippled rectangle"] = 5;
>-	weight["(xor) 100x10 wide line"] = 5;
>-	weight["(xor) 100x10 wide horizontal line segment"] = 5;
>-	weight["(xor) 100x10 wide vertical line segment"] = 5;
>-	weight["(xor) Scroll 100x100 pixels"] = 5;
>-	weight["(xor) Char16 in 23-char line (k24)"] = 5;
>-	weight["(xor) Dot"] = 5;
>-	weight["(xor) Copy 500x500 1-bit deep plane"] = 5;
>-	weight["(xor) 100-pixel ellipse"] = 5;
>-	weight["(xor) 100x100 4x4 tiled rectangle"] = 5;
>-	weight["(xor) Copy 10x10 1-bit deep plane"] = 5;
>-	weight["(xor) 1x1 rectangle"] = 5;
>-	weight["(xor) 500-pixel solid circle"] = 4;
>-	weight["(xor) 500-pixel filled ellipse"] = 4;
>-	weight["(xor) 10-pixel filled ellipse"] = 4;
>-	weight["(xor) Fill 100x100 stippled trapezoid"] = 4;
>-	weight["(xor) 500x50 wide line"] = 4;
>-	weight["(xor) 500-pixel circle"] = 4;
>-	weight["(xor) 100-pixel double-dashed line"] = 4;
>-	weight["(xor) 500x50 wide horizontal line segment"] = 4;
>-	weight["(xor) 500x50 wide vertical line segment"] = 4;
>-	weight["(xor) 100-pixel dashed circle"] = 4;
>-	weight["(xor) 10x10 opaque stippled rectangle"] = 4;
>-	weight["(xor) 10-pixel ellipse"] = 4;
>-	weight["(xor) Copy 500x500 from pixmap to pixmap"] = 4;
>-	weight["(xor) 100x100 161x145 stippled rectangle"] = 4;
>-	weight["(xor) 10x10 161x145 tiled rectangle"] = 4;
>-	weight["(xor) Copy 10x10 from window to window"] = 4;
>-	weight["(xor) Copy 10x10 from pixmap to pixmap"] = 4;
>-	weight["(xor) 10x10 161x145 stippled rectangle"] = 4;
>-	weight["(xor) 100-pixel wide circle"] = 4;
>-	weight["(xor) 500x500 stippled rectangle"] = 4;
>-	weight["(xor) 500-pixel ellipse"] = 4;
>-	weight["(xor) 10x10 216x208 tiled rectangle"] = 4;
>-	weight["(xor) Fill 100x100 equivalent complex polygons"] = 4;
>-	weight["(xor) 100-pixel double-dashed segment"] = 3;
>-	weight["(xor) 10x10 161x145 opaque stippled rectangle"] = 3;
>-	weight["(xor) Fill 10x10 opaque stippled trapezoid"] = 3;
>-	weight["(xor) 100-pixel partial circle"] = 3;
>-	weight["(xor) Fill 10x10 161x145 stippled trapezoid"] = 3;
>-	weight["(xor) Fill 10x10 161x145 opaque stippled trapezoid"] = 3;
>-	weight["(xor) Scroll 500x500 pixels"] = 3;
>-	weight["(xor) 100x100 opaque stippled rectangle"] = 3;
>-	weight["(xor) Fill 10x10 stippled trapezoid"] = 3;
>-	weight["(xor) 100x10 wide dashed line"] = 3;
>-	weight["(xor) Copy 10x10 from window to pixmap"] = 3;
>-	weight["(xor) Copy 500x500 from window to pixmap"] = 3;
>-	weight["(xor) 500x500 opaque stippled rectangle"] = 3;
>-	weight["(xor) Fill 10x10 tiled trapezoid"] = 3;
>-	weight["(xor) 100x100 161x145 tiled rectangle"] = 3;
>-	weight["(xor) 100-pixel partial ellipse"] = 3;
>-	weight["(xor) 100-pixel fill slice partial circle"] = 3;
>-	weight["(xor) Fill 1x1 equivalent triangle"] = 3;
>-	weight["(xor) 100-pixel double-dashed circle"] = 3;
>-	weight["(xor) 500x500 4x4 tiled rectangle"] = 3;
>-	weight["(xor) 100-pixel wide ellipse"] = 3;
>-	weight["(xor) 100-pixel fill chord partial circle"] = 3;
>-	weight["(xor) 100x100 216x208 tiled rectangle"] = 3;
>-	weight["(xor) Fill 10x10 161x145 tiled trapezoid"] = 3;
>-	weight["(xor) Fill 100x100 216x208 tiled trapezoid"] = 3;
>-	weight["(xor) 500x500 161x145 stippled rectangle"] = 3;
>-	weight["(xor) 500x500 161x145 tiled rectangle"] = 3;
>-	weight["(xor) 100x100 161x145 opaque stippled rectangle"] = 3;
>-	weight["(xor) 500x500 161x145 opaque stippled rectangle"] = 3;
>-	weight["(xor) 10x1 wide line"] = 3;
>-	weight["(xor) 500x500 216x208 tiled rectangle"] = 3;
>-	weight["(xor) 100-pixel dashed ellipse"] = 3;
>-	weight["(xor) Fill 100x100 opaque stippled trapezoid"] = 3;
>-	weight["(xor) 10-pixel partial circle"] = 3;
>-	weight["(xor) 100x10 wide double-dashed line"] = 3;
>-	weight["(xor) Fill 100x100 161x145 stippled trapezoid"] = 3;
>-	weight["(xor) Fill 100x100 161x145 opaque stippled trapezoid"] = 3;
>-	weight["(xor) 100-pixel fill slice partial ellipse"] = 3;
>-	weight["(xor) 1-pixel circle"] = 3;
>-	weight["(xor) Fill 10x10 equivalent complex polygon"] = 3;
>-	weight["(xor) 100-pixel wide dashed circle"] = 2;
>-	weight["(xor) 100-pixel wide double-dashed circle"] = 2;
>-	weight["(xor) Scroll 10x10 pixels"] = 2;
>-	weight["(xor) 10-pixel wide circle"] = 2;
>-	weight["(xor) 100-pixel fill chord partial ellipse"] = 2;
>-	weight["(xor) Fill 100x100 tiled trapezoid"] = 2;
>-	weight["(xor) 100-pixel double-dashed ellipse"] = 2;
>-	weight["(xor) 100-pixel wide dashed ellipse"] = 2;
>-	weight["(xor) 100-pixel wide double-dashed ellipse"] = 2;
>-	weight["(xor) 10-pixel partial ellipse"] = 2;
>-	weight["(xor) 100-pixel wide partial circle"] = 2;
>-	weight["(xor) 100-pixel wide partial ellipse"] = 2;
>-	weight["(xor) 10-pixel fill slice partial circle"] = 2;
>-	weight["(xor) 10-pixel wide ellipse"] = 2;
>-	weight["(xor) Fill 100x100 161x145 tiled trapezoid"] = 2;
>-	weight["(xor) Fill 10x10 216x208 tiled trapezoid"] = 2;
>-	weight["(xor) 10-pixel fill chord partial circle"] = 2;
>-	weight["(xor) 500-pixel wide circle"] = 2;
>-	weight["(xor) 500-pixel wide ellipse"] = 2;
>-	weight["(xor) 1-pixel solid circle"] = 2;
>-	weight["(xor) 10-pixel fill chord partial ellipse"] = 2;
>-	weight["(xor) 10-pixel fill slice partial ellipse"] = 2;
>-	weight["(xor) 10-pixel wide partial circle"] = 1;
>-	weight["(xor) 10-pixel wide partial ellipse"] = 1;
>-	weight["(xor) 1x1 stippled rectangle"] = 1;
>-	weight["(xor) 1x1 161x145 stippled rectangle"] = 1;
>-	weight["(xor) 1x1 opaque stippled rectangle"] = 1;
>-	weight["(xor) 1x1 161x145 opaque stippled rectangle"] = 1;
>-	weight["(xor) 1x1 4x4 tiled rectangle"] = 1;
>-	weight["(xor) 1x1 161x145 tiled rectangle"] = 1;
>-	weight["(xor) 1x1 216x208 tiled rectangle"] = 1;
>-	weight["(xor) ShmPutImage 10x10 square"] = 0;
>-	weight["(xor) ShmPutImage 100x100 square"] = 0;
>-	weight["(xor) ShmPutImage 500x500 square"] = 0;
>-	sumofweights = 0;
>-    }
>-    $0 ~ /server/ {
>-	printf("name:%s\n",substr($0,1,index($0,"server")-2));
>-    }
>-    {
>-	split($0,parts,":");			# get rate and name
>-	start = index(parts[1],"(") + 1;	# find left parentheses
>-	end = index(parts[1],"/");		# find terminating '/'
>-	rate = substr(parts[1],start,end-start);# get ops/sec
>-
>-	name = parts[2];
>-	while (substr(name,1,1) == " ") {	# remove leading spaces
>-	    name = substr(name,2,length(name));
>-	}
>-
>-	thisweight = weight[name];
>-	weight[name] = 0;			# clear to avoid double counting
>-	sumofweights += thisweight;
>-	printf("%d:",thisweight);		# output in new format
>-	printf("%9.1f\n",rate);
>-    }
>-    END{
>-	printf("sumof:%9.1f\n",sumofweights);
>-    }
>-EOS
>-
>-awk -f awkfile.$$ temp.$$ > rates.$$
>-rm -f awkfile.$$				# cleanup
>-
>-# calculate the weighted average 
>-
>-sumofweights=`grep sumof rates.$$ | awk -F: ' { print($2) }' - `
>-if [ "$sumofweights" -ne "4566" ]
>-then
>-    echo "ERROR: sum of weights =$sumofweights, not equal to 4566.0;"
>-    echo "ABORTING!"
>-    rm -f rates.$$ temp.$$
>-    exit 1
>-fi
>-
>-awk -F: '
>-    BEGIN {
>-	logsum = 0;
>-	name = "tested"
>-    }
>-    $1 == "name" { name = $2;next }
>-    {
>-	weight = $1;
>-	rate = $2;
>-	if (rate > 0.0) {
>-	    # generate weighted log sum
>-	    logsum += ( log( rate ) * weight );
>-	}
>-    }
>-    END {
>-	SparcStation1 = 2118.51;
>-	WeightedAverage = exp(logsum/4566.0);
>-	printf("Weighted x11perf of %s server =%6.0f\n", name,WeightedAverage);
>-	printf("Weighted x11perf of SparcStation 1 server =%5.0f\n", SparcStation1);
>-	printf("Xmark =%8.4f\n", WeightedAverage/SparcStation1);
>-    }' rates.$$	
>-
>-rm -f temp.$$ rates.$$ awkfile.$$			# cleanup
>-
>-exit 0
>Index: xc/programs/x11perf/bitmaps.c
>===================================================================
>RCS file: xc/programs/x11perf/bitmaps.c
>diff -N xc/programs/x11perf/bitmaps.c
>--- xc/programs/x11perf/bitmaps.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,878 +0,0 @@
>-/* $Xorg: bitmaps.c,v 1.3 2000/08/17 19:54:08 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-#include "bitmaps.h"
>-
>-static unsigned char bitmap8x8[] = {
>-    0xCC, 0x66, 0x33, 0x99, 0xCC, 0x66, 0x33, 0x99
>-/* Alternate maps for testing out your stipple code.  Only the above should
>-   be used for timing, though.
>-    0x00, 0xfe, 0x92, 0x92, 0xfe, 0x92, 0x92, 0xfe
>-    0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA
>-*/
>-};
>-
>-static unsigned char bitmap4x4[] = {
>-   0x03, 0x06, 0x0c, 0x09
>-};
>-
>-#define oddbit_width 17
>-#define oddbit_height 15
>-static unsigned char oddbit_bits[] = {
>-   0x01, 0x00, 0x01, 0xc2, 0x87, 0x00, 0x34, 0x58, 0x00, 0x08, 0x20, 0x00,
>-   0x38, 0x38, 0x00, 0x44, 0x44, 0x00, 0x84, 0x42, 0x00, 0x04, 0x41, 0x00,
>-   0x84, 0x42, 0x00, 0x44, 0x44, 0x00, 0x28, 0x28, 0x00, 0x18, 0x30, 0x00,
>-   0x34, 0x58, 0x00, 0xc2, 0x87, 0x00, 0x01, 0x00, 0x01};
>-
>-/* A big bitmap */
>-#define mensetmanus_width 161
>-#define mensetmanus_height 145
>-
>-static unsigned char mensetmanus_bits[] = {
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff,
>- 0x01, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x07, 0x00, 0x00,
>- 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x3f, 0xdb, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x07,
>- 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xf7, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x61, 0x00, 0x00, 0xc6,
>- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc3, 0xff,
>- 0x1f, 0x00, 0x00, 0x00, 0xc0, 0xe1, 0xff, 0xff, 0x87, 0x01, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc3, 0xf6, 0x1f, 0x00, 0x00,
>- 0x00, 0xc0, 0xc0, 0xff, 0xff, 0x87, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x80, 0x9f, 0x65, 0x1f, 0x00, 0x00, 0x00, 0xc0, 0x00,
>- 0x07, 0x80, 0x87, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x80, 0x9f, 0x6d, 0x1f, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xff, 0xff, 0xc7,
>- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x89, 0x6d,
>- 0x1b, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x81, 0x6d, 0x1b, 0x00, 0x00,
>- 0x00, 0xc0, 0xe1, 0x5b, 0xdb, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0xc0, 0x81, 0x6d, 0x1b, 0x00, 0x00, 0x00, 0x80, 0x83,
>- 0x5b, 0xdb, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0xc0, 0x81, 0x6d, 0x1b, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x5b, 0x1b, 0x0c,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x6d,
>- 0x1b, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x5b, 0x1b, 0x0c, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x80, 0x6d, 0x1b, 0x00, 0x00,
>- 0x00, 0x00, 0xf8, 0x5b, 0x0b, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0xe0, 0x83, 0x6d, 0x19, 0x00, 0x00, 0x00, 0x00, 0x80,
>- 0x5b, 0x0b, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0xe0, 0x83, 0x6d, 0x1b, 0x00, 0x00, 0x00, 0x00, 0x80, 0x5b, 0x0f, 0x0e,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x6d,
>- 0x1b, 0x00, 0x00, 0x00, 0x00, 0x80, 0x4b, 0x0f, 0x07, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x79, 0x1b, 0x00, 0x00,
>- 0x00, 0x00, 0x80, 0x6b, 0xbf, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x03, 0xfb, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x80,
>- 0x6d, 0xb7, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x03, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xed, 0xf7, 0x07,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0xfe,
>- 0x7f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xed, 0xd7, 0x07, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x7f, 0xf8, 0xff, 0x07, 0x00,
>- 0x00, 0x00, 0xe0, 0xfe, 0xd7, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x80, 0xff, 0x7f, 0xe0, 0xff, 0x3f, 0x00, 0x00, 0x00, 0xf0,
>- 0xff, 0xd6, 0xfe, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
>- 0xbf, 0x73, 0x80, 0x3b, 0x7c, 0x00, 0x00, 0x00, 0xf8, 0xe7, 0xd6, 0xef,
>- 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xb9, 0x73, 0xc0,
>- 0x3b, 0xf0, 0x01, 0x00, 0x00, 0xff, 0xc3, 0xbf, 0xe7, 0x3f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xb8, 0x7f, 0xe0, 0x3b, 0xc0, 0x03,
>- 0x00, 0xc0, 0xbf, 0xc7, 0xbf, 0xe7, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x1c, 0xb8, 0xff, 0xf8, 0x3b, 0x80, 0x07, 0x00, 0xe0, 0x61,
>- 0x87, 0xfd, 0xe7, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
>- 0xb8, 0xf3, 0xff, 0x3b, 0x00, 0x0f, 0x00, 0x78, 0x60, 0x8e, 0xf1, 0x67,
>- 0xc7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xb8, 0xc3, 0x8f,
>- 0x7b, 0x00, 0x0e, 0x00, 0x38, 0xe0, 0x8c, 0x03, 0x66, 0x87, 0x03, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x80, 0x07, 0xb8, 0x03, 0x83, 0x7b, 0x00, 0x1e,
>- 0x00, 0x1c, 0xe0, 0x1d, 0x03, 0x76, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xc0, 0x07, 0xb8, 0xe3, 0x8f, 0xbb, 0x01, 0x39, 0x00, 0x1e, 0xe0,
>- 0x3b, 0x03, 0xf6, 0x87, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x0f,
>- 0xb8, 0xe3, 0x8f, 0x3b, 0xc6, 0x38, 0x00, 0x17, 0xe0, 0x73, 0x07, 0xfe,
>- 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x0b, 0xb8, 0xe7, 0x8e,
>- 0x3b, 0x38, 0x78, 0x00, 0x13, 0xe0, 0x77, 0x06, 0xfe, 0xff, 0xff, 0xff,
>- 0x0f, 0x00, 0x00, 0x00, 0xe0, 0x12, 0x3c, 0xff, 0xce, 0x3b, 0x00, 0x78,
>- 0x80, 0x13, 0x60, 0xef, 0x0e, 0xfe, 0x00, 0x00, 0x60, 0x08, 0x00, 0x00,
>- 0x00, 0x70, 0x22, 0x3e, 0xfc, 0xfe, 0x39, 0x00, 0xe8, 0x80, 0x61, 0x60,
>- 0xce, 0x0f, 0xfe, 0x00, 0x00, 0x60, 0xf8, 0x00, 0x00, 0x00, 0x70, 0xc2,
>- 0x39, 0xf8, 0x7e, 0x38, 0x00, 0xc8, 0xc0, 0x81, 0x71, 0xde, 0x0f, 0xfe,
>- 0x00, 0x00, 0x60, 0x88, 0x00, 0x00, 0x00, 0x70, 0x04, 0x38, 0xe0, 0x0e,
>- 0x38, 0x00, 0xc4, 0xc0, 0x01, 0x7e, 0xbc, 0x1f, 0xfe, 0x00, 0x00, 0x60,
>- 0x88, 0x00, 0x00, 0x00, 0x78, 0x04, 0x38, 0xe0, 0x0e, 0x38, 0x00, 0xc4,
>- 0xc1, 0x01, 0x60, 0x3c, 0x1f, 0xfe, 0x00, 0x00, 0x60, 0x84, 0x0f, 0x00,
>- 0x00, 0x78, 0x08, 0x38, 0xe0, 0x0f, 0x38, 0x00, 0x82, 0xe1, 0x01, 0x60,
>- 0x74, 0x3e, 0xfe, 0x00, 0x00, 0x60, 0x44, 0x08, 0x00, 0x00, 0xb8, 0x10,
>- 0x38, 0xe0, 0x0f, 0x38, 0x00, 0x81, 0xe1, 0x00, 0x60, 0xe4, 0x3e, 0xfe,
>- 0x00, 0x00, 0x60, 0x44, 0x08, 0x00, 0x00, 0x98, 0x20, 0x38, 0xf8, 0x3f,
>- 0x38, 0x80, 0x80, 0xe1, 0x01, 0x60, 0xc4, 0x3c, 0xfe, 0x00, 0x00, 0x60,
>- 0x24, 0x0c, 0x00, 0x00, 0x1c, 0xc1, 0x39, 0x3c, 0x78, 0x38, 0x40, 0x80,
>- 0x61, 0x01, 0x60, 0xc4, 0x79, 0xfe, 0x00, 0x00, 0x60, 0x22, 0x32, 0x00,
>- 0x00, 0x1c, 0x01, 0x3e, 0x1c, 0xf0, 0x38, 0xf0, 0x9f, 0x61, 0x01, 0x60,
>- 0x84, 0x7b, 0xee, 0x00, 0x00, 0x60, 0x12, 0x21, 0x00, 0x00, 0x1c, 0x02,
>- 0x38, 0x0e, 0xe7, 0xf8, 0x3f, 0xe0, 0x61, 0x00, 0x60, 0x04, 0xf7, 0xce,
>- 0x00, 0x00, 0x60, 0x92, 0x10, 0x00, 0x00, 0x1c, 0x04, 0x38, 0x06, 0xff,
>- 0x38, 0x40, 0x80, 0x61, 0x02, 0x60, 0x04, 0xe7, 0xcf, 0x00, 0x00, 0x60,
>- 0x8a, 0x18, 0x00, 0x00, 0x1c, 0x18, 0x38, 0x07, 0xf0, 0x38, 0x00, 0x81,
>- 0x61, 0x02, 0x60, 0x04, 0xee, 0xcf, 0xff, 0x03, 0x60, 0x49, 0xe4, 0x00,
>- 0x00, 0x1c, 0x70, 0x38, 0x07, 0xe7, 0x38, 0x00, 0x82, 0x61, 0x04, 0x60,
>- 0x04, 0xdc, 0xcf, 0x01, 0x04, 0x60, 0x25, 0x42, 0x00, 0x00, 0x1c, 0xfe,
>- 0x3f, 0x03, 0xff, 0x38, 0x00, 0x84, 0x61, 0x08, 0x60, 0x04, 0xfc, 0xcf,
>- 0xf8, 0xff, 0x60, 0x95, 0x31, 0x00, 0x00, 0xfc, 0x01, 0xff, 0x03, 0xf0,
>- 0xf8, 0x1f, 0x88, 0x61, 0x10, 0xe0, 0xff, 0xff, 0xff, 0x00, 0x00, 0xe1,
>- 0x53, 0x0c, 0x00, 0x00, 0x38, 0xf0, 0xff, 0x03, 0xef, 0xf8, 0x7f, 0x90,
>- 0x61, 0x40, 0xe0, 0xff, 0xff, 0xff, 0x00, 0xff, 0xe3, 0x2b, 0xfe, 0x00,
>- 0x00, 0x18, 0xf8, 0xff, 0x03, 0xff, 0x7c, 0xf0, 0x90, 0x61, 0x00, 0x3e,
>- 0x36, 0xe3, 0xe1, 0x00, 0x00, 0xe3, 0x9f, 0x60, 0x00, 0x00, 0x38, 0x3c,
>- 0x00, 0x03, 0xf0, 0x1f, 0xe0, 0xa0, 0xe1, 0x00, 0x30, 0x22, 0xe2, 0xc0,
>- 0x00, 0xff, 0xe3, 0x7f, 0x18, 0x00, 0x00, 0x38, 0x0e, 0x00, 0x07, 0xe7,
>- 0x07, 0xc0, 0xe1, 0xc1, 0x00, 0x18, 0x22, 0xe2, 0xc0, 0x00, 0x00, 0xe1,
>- 0x1f, 0x07, 0x00, 0x00, 0x38, 0x06, 0x00, 0x07, 0xef, 0x01, 0xc0, 0xc1,
>- 0xc1, 0x01, 0x16, 0x24, 0xe2, 0xc0, 0x01, 0xff, 0xe1, 0xff, 0x00, 0x00,
>- 0x00, 0x70, 0x07, 0x00, 0x0e, 0xf8, 0x00, 0x80, 0xc3, 0xc0, 0xf1, 0x11,
>- 0x24, 0xe4, 0xc0, 0x03, 0xe0, 0xe1, 0x7f, 0x00, 0x00, 0x00, 0x70, 0x07,
>- 0x00, 0x1e, 0x3c, 0x00, 0x80, 0xe3, 0x80, 0x0f, 0x10, 0x24, 0xe4, 0xc0,
>- 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0xe0, 0x03, 0x00, 0xfc, 0x0f,
>- 0x00, 0x00, 0x63, 0x80, 0x01, 0x08, 0x44, 0xe4, 0xc0, 0xff, 0xff, 0xff,
>- 0xff, 0xff, 0x01, 0x00, 0xe0, 0x03, 0x00, 0xf8, 0x07, 0x00, 0x00, 0x73,
>- 0x80, 0x03, 0x08, 0x44, 0xe4, 0xc0, 0xfc, 0x00, 0x07, 0x0e, 0x00, 0x00,
>- 0x00, 0xc0, 0x03, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x33, 0x00, 0x03, 0x08,
>- 0x44, 0xe4, 0xe0, 0xcc, 0x00, 0x07, 0x0e, 0x00, 0x00, 0x00, 0xc0, 0x03,
>- 0x00, 0x78, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x07, 0x04, 0x44, 0xe8, 0x70,
>- 0xcc, 0x01, 0x87, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x07, 0x00, 0x3e, 0x00,
>- 0x00, 0x80, 0x1f, 0x00, 0x0e, 0x04, 0x44, 0xe8, 0x38, 0xcc, 0x81, 0xe7,
>- 0x03, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x00, 0x80, 0x0f,
>- 0x00, 0x1c, 0x02, 0x44, 0xf8, 0x1e, 0xcc, 0xe1, 0xff, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x0f, 0xc0, 0x23, 0x00, 0x00, 0xc0, 0x07, 0x00, 0x38, 0x01,
>- 0x42, 0xfc, 0x0f, 0xcc, 0xf1, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
>- 0xf0, 0x39, 0x00, 0x00, 0xe0, 0x03, 0x00, 0xf0, 0x00, 0xc2, 0xff, 0x07,
>- 0xcc, 0x7f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x7c, 0x0e, 0x00,
>- 0x00, 0xf0, 0x01, 0x00, 0xe0, 0x03, 0xe2, 0xe7, 0x07, 0xcc, 0x1f, 0x07,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xbf, 0x23, 0xe0, 0xff, 0xff, 0x00,
>- 0x00, 0xc0, 0x1f, 0xff, 0x64, 0x06, 0xcc, 0x07, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0xf0, 0xff, 0x3c, 0xf0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xff,
>- 0x7f, 0x64, 0x06, 0xcc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70,
>- 0xf8, 0x1f, 0x78, 0x7c, 0x7f, 0x00, 0x00, 0x00, 0xfc, 0x20, 0x64, 0x06,
>- 0xcc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xf8, 0x33, 0x1c,
>- 0x38, 0x66, 0x00, 0x00, 0x00, 0x0c, 0x20, 0x6c, 0x06, 0xcc, 0x03, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x78, 0x3e, 0x0e, 0x38, 0x76, 0x00,
>- 0x00, 0x00, 0x0c, 0x20, 0x68, 0x06, 0xcc, 0x03, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x38, 0xf8, 0x87, 0x0f, 0x38, 0x76, 0x00, 0x00, 0x00, 0x0c,
>- 0x20, 0x68, 0x06, 0xcc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38,
>- 0x78, 0xf8, 0x0f, 0x38, 0x76, 0x00, 0x00, 0x00, 0x0c, 0x10, 0x68, 0x06,
>- 0xcc, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xf8, 0xff, 0x0f,
>- 0x38, 0x76, 0x00, 0x00, 0x00, 0x0c, 0x10, 0x68, 0x06, 0xcc, 0x07, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xf8, 0xff, 0x0e, 0x38, 0x76, 0x00,
>- 0x00, 0x00, 0x0c, 0x10, 0x68, 0x06, 0xcc, 0x07, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x1c, 0xf8, 0xe1, 0x0e, 0x38, 0x3e, 0x00, 0x00, 0x00, 0x0c,
>- 0x08, 0x68, 0x06, 0xcc, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c,
>- 0x38, 0xe0, 0x0e, 0x38, 0x3e, 0x00, 0x00, 0x00, 0x0c, 0x08, 0x68, 0x06,
>- 0xcc, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x38, 0xe0, 0x0e,
>- 0x38, 0x3e, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x68, 0x06, 0xcc, 0x0e, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x38, 0xe0, 0x0e, 0x38, 0x3e, 0x00,
>- 0x00, 0x00, 0x1c, 0x04, 0x68, 0x06, 0xcc, 0x0e, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x06, 0x38, 0xe0, 0x0e, 0x38, 0x3e, 0x00, 0x00, 0x00, 0x1c,
>- 0x02, 0x68, 0x06, 0xcc, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
>- 0x38, 0xe0, 0x0e, 0x38, 0x3e, 0x00, 0x00, 0x00, 0x1c, 0x02, 0x68, 0x06,
>- 0xcc, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x38, 0xe0, 0x0e,
>- 0x38, 0x3e, 0x00, 0x00, 0x00, 0x1c, 0x01, 0x68, 0x06, 0xcc, 0x1c, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x38, 0xe0, 0x0e, 0x38, 0x3e, 0x00,
>- 0x00, 0x00, 0x18, 0x01, 0x68, 0x06, 0xcc, 0x1c, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x03, 0x38, 0xe0, 0x0e, 0x38, 0x3e, 0x00, 0x00, 0x00, 0x98,
>- 0x00, 0x68, 0x06, 0xcc, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03,
>- 0x38, 0xe0, 0x0e, 0x38, 0x3e, 0x00, 0x00, 0x00, 0x98, 0x00, 0x68, 0x06,
>- 0xcc, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x38, 0xe0, 0x0e,
>- 0x38, 0x1e, 0x00, 0x00, 0x00, 0x58, 0x00, 0x6c, 0x0e, 0xcc, 0x18, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x30, 0xe0, 0x0e, 0x38, 0x1e, 0x00,
>- 0x00, 0x00, 0x38, 0x00, 0x64, 0x0e, 0xcc, 0x18, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xc0, 0x01, 0x70, 0xe0, 0x0e, 0x1c, 0x1e, 0x00, 0x00, 0x00, 0x18,
>- 0x00, 0x64, 0x1e, 0xcc, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x01,
>- 0xe0, 0xe1, 0x0e, 0x0f, 0x1e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x64, 0x3e,
>- 0xcc, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0xef, 0xce,
>- 0x07, 0x1e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x64, 0x3e, 0xcc, 0x30, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0xff, 0xfe, 0x03, 0x1e, 0x00,
>- 0x00, 0x00, 0x18, 0x00, 0x64, 0x7e, 0xcc, 0x30, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x00, 0x00, 0xfc, 0xfe, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x18,
>- 0x00, 0x64, 0x66, 0xcc, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00,
>- 0x00, 0xe0, 0x1e, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x66, 0xe6,
>- 0xcc, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0xe0, 0x0e,
>- 0x00, 0x1e, 0x00, 0x00, 0x00, 0x18, 0x00, 0x62, 0xc6, 0xcd, 0x70, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0xfe, 0xff, 0x0f, 0x1e, 0x00,
>- 0x00, 0x00, 0x18, 0x00, 0x62, 0xc6, 0xcd, 0x70, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x70, 0x00, 0xc0, 0xff, 0xff, 0x0f, 0x0e, 0x00, 0x00, 0x00, 0x38,
>- 0x00, 0x62, 0x86, 0xcf, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00,
>- 0xf0, 0xff, 0xff, 0x0f, 0x0e, 0x00, 0x00, 0x00, 0x38, 0x00, 0x61, 0x86,
>- 0xcf, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0xfc, 0x00, 0x00,
>- 0x0e, 0x0e, 0x00, 0x00, 0x00, 0x38, 0x00, 0x61, 0x8e, 0xcf, 0xe0, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x78, 0x00, 0x00, 0x0e, 0x0e, 0x00,
>- 0x00, 0x00, 0xf8, 0xff, 0x7f, 0xfe, 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x18, 0x00, 0xf0, 0x00, 0x00, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0xf0,
>- 0xff, 0x3f, 0xff, 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00,
>- 0xe0, 0x01, 0x00, 0x0e, 0x0e, 0x00, 0x00, 0x00, 0xf0, 0xff, 0x8f, 0x07,
>- 0x9e, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0xe0, 0x07, 0x00,
>- 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x30, 0x00, 0xc0, 0xff, 0x3f, 0xc0, 0x01,
>- 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x0f, 0x00,
>- 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
>- 0x00, 0x1c, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0xf0,
>- 0xff, 0xff, 0x00, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff,
>- 0x3f, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x38, 0x00,
>- 0x38, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x7f, 0x00, 0x00,
>- 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x38, 0x00, 0x38, 0xe0, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x06, 0x00,
>- 0x00, 0x00, 0x00, 0x06, 0x18, 0x00, 0x38, 0xe0, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
>- 0x06, 0x18, 0x00, 0x38, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00,
>- 0xdc, 0x01, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x1c, 0x00,
>- 0x38, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x9c, 0x03, 0x00,
>- 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x1c, 0x00, 0x18, 0x70, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x07, 0x00, 0x00, 0x06, 0x00,
>- 0x00, 0x00, 0x00, 0x07, 0x0c, 0x00, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x00, 0x1c, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
>- 0x07, 0x0c, 0x00, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00,
>- 0x1c, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0c, 0x00,
>- 0x18, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x1c, 0x00,
>- 0x80, 0x07, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0e, 0x00, 0x18, 0x70, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x1c, 0x00, 0x80, 0x03, 0x00,
>- 0x00, 0x00, 0x00, 0x07, 0x0e, 0x00, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x00, 0x1c, 0x1c, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00,
>- 0x07, 0x0e, 0x00, 0x18, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00,
>- 0x1c, 0x1c, 0x00, 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0e, 0x00,
>- 0x18, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x1c, 0x00,
>- 0x80, 0x03, 0x00, 0x00, 0x00, 0x00, 0x07, 0x06, 0x00, 0x18, 0x38, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00,
>- 0x00, 0x00, 0x00, 0x07, 0x06, 0x00, 0x18, 0x38, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
>- 0x07, 0x0e, 0x00, 0x18, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00,
>- 0x1c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0e, 0x00,
>- 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x00, 0x00,
>- 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0e, 0x00, 0x18, 0x30, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x06, 0x00,
>- 0x00, 0x00, 0x00, 0x07, 0x0e, 0x00, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
>- 0x07, 0x0e, 0x00, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00,
>- 0x1e, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0c, 0x00,
>- 0x38, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1e, 0x00, 0x00,
>- 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x1c, 0x00, 0x38, 0x70, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x06, 0x00,
>- 0x00, 0x00, 0x00, 0x06, 0x1c, 0x00, 0x38, 0xe0, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
>- 0x06, 0x18, 0x00, 0x38, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00,
>- 0x1e, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x18, 0x00,
>- 0x30, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x1e, 0x00, 0x00,
>- 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x38, 0x00, 0x30, 0xe0, 0x01,
>- 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x1f, 0x00, 0x00, 0x00, 0x06, 0x00,
>- 0x00, 0x00, 0x00, 0x0c, 0x3c, 0x00, 0x30, 0xf0, 0x01, 0x00, 0x00, 0x00,
>- 0x00, 0xf8, 0x03, 0x1f, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
>- 0x0c, 0x7e, 0x00, 0x70, 0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x0f,
>- 0x1f, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe7, 0x00,
>- 0x70, 0xbc, 0x03, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x1e, 0x1f, 0x00, 0x00,
>- 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0xdc, 0xe3, 0x00, 0x60, 0x1e, 0x07,
>- 0x00, 0x00, 0x00, 0x00, 0x0f, 0xfc, 0x1f, 0x00, 0x00, 0x00, 0x06, 0x00,
>- 0x00, 0x00, 0x00, 0xfc, 0xc1, 0x01, 0xe0, 0x0f, 0x0f, 0x00, 0x00, 0x00,
>- 0x80, 0x07, 0xf0, 0x1f, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
>- 0xf8, 0x80, 0x03, 0xe0, 0x03, 0x1e, 0x00, 0x00, 0x00, 0xc0, 0x03, 0xe0,
>- 0x1b, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x78, 0x80, 0x07,
>- 0xe0, 0x01, 0x1c, 0x00, 0x00, 0x00, 0xe0, 0x01, 0xc0, 0x1b, 0x00, 0x00,
>- 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x0f, 0xe0, 0x01, 0x38,
>- 0x00, 0x00, 0x00, 0xf0, 0x00, 0xc0, 0x19, 0x00, 0x00, 0x00, 0x06, 0x00,
>- 0x00, 0x00, 0x00, 0x30, 0x0e, 0x1e, 0xc0, 0x71, 0xf8, 0x00, 0x00, 0x00,
>- 0x78, 0x00, 0xdc, 0x19, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
>- 0x30, 0x1f, 0x1e, 0xc0, 0xf9, 0xf8, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff,
>- 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff,
>- 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
>- 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff,
>- 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
>-
>-#define escherknot_width 216
>-#define escherknot_height 208
>-
>-static unsigned char escherknot_bits[] = {
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x5f,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0xf0, 0x6f, 0xf6, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0xc0, 0xff, 0x3a, 0x13, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x0d, 0x02, 0x51, 0x71, 0x0e, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x2f, 0x20, 0xd9, 0x88,
>- 0x9b, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x82,
>- 0xac, 0x44, 0x4e, 0x1c, 0xf3, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x1e, 0x40, 0x02, 0x44, 0x60, 0xe2, 0xfc, 0x06, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x80, 0x25, 0x09, 0x90, 0x22, 0x13, 0xb7, 0x9a, 0x1e,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x40, 0x10, 0x89,
>- 0x18, 0xe3, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x04, 0x08,
>- 0x01, 0x10, 0xc8, 0xa8, 0xd5, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x83, 0x80, 0x20, 0x40, 0x82, 0x00, 0x66, 0x9c, 0xec, 0x01, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x08, 0x08, 0x24, 0x12, 0x93, 0x5b,
>- 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x12, 0x80, 0x04, 0x01, 0x00, 0x80,
>- 0x19, 0x33, 0xfa, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x80, 0x80, 0x00,
>- 0x20, 0x08, 0x12, 0xc4, 0x68, 0x26, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
>- 0x02, 0x04, 0x24, 0x00, 0x01, 0x40, 0x24, 0x8c, 0xcd, 0x3f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
>- 0x00, 0x80, 0x49, 0x10, 0x90, 0x00, 0x21, 0x20, 0x08, 0x11, 0x43, 0xd9,
>- 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8,
>- 0xff, 0xff, 0x0b, 0x00, 0x60, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x80, 0x30, 0xb9, 0xf2, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xc0, 0x97, 0x04, 0x08, 0xfe, 0x05, 0x30, 0x10, 0x12, 0x20, 0x20,
>- 0x04, 0x00, 0x80, 0x48, 0x0c, 0xa3, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x3e, 0x92, 0x20, 0x49, 0x40, 0x3e, 0x0e, 0x82,
>- 0x00, 0x84, 0x25, 0x01, 0x80, 0x00, 0x80, 0xc8, 0x34, 0xed, 0x03, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x25, 0x01, 0x04, 0x01, 0x08,
>- 0xd0, 0x17, 0x00, 0x80, 0x25, 0x01, 0xad, 0x04, 0x12, 0x20, 0x23, 0x4c,
>- 0x6a, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x02, 0x48,
>- 0x92, 0x20, 0x41, 0x92, 0x9e, 0x80, 0x24, 0x24, 0x29, 0x00, 0x04, 0x00,
>- 0x10, 0x98, 0xcc, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
>- 0x4f, 0x10, 0x01, 0x90, 0x24, 0x40, 0x12, 0xf0, 0x00, 0x24, 0x41, 0x0b,
>- 0xa9, 0x10, 0x00, 0x00, 0x04, 0xd9, 0x96, 0x0e, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0xe0, 0x00, 0x92, 0x48, 0x02, 0x04, 0x09, 0xc0, 0x84, 0x8f,
>- 0x29, 0x2d, 0xf8, 0xa9, 0x02, 0x00, 0x00, 0x20, 0x90, 0xf4, 0x1e, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0x24, 0x91, 0x04, 0x50, 0x22, 0x24,
>- 0x1b, 0x12, 0x7a, 0x48, 0xca, 0x03, 0x21, 0x10, 0x00, 0x00, 0x48, 0x93,
>- 0xff, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9e, 0x24, 0x92, 0x20,
>- 0x81, 0xda, 0x24, 0xc8, 0x16, 0xd0, 0xe7, 0x50, 0xd2, 0xbf, 0x03, 0x00,
>- 0x80, 0x00, 0x30, 0x29, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03,
>- 0x20, 0x80, 0x24, 0x41, 0x12, 0x2a, 0x41, 0xb2, 0x80, 0x33, 0x0e, 0x7e,
>- 0x88, 0x1c, 0x01, 0x00, 0xa0, 0x24, 0x69, 0x75, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xe0, 0x82, 0x44, 0x11, 0x24, 0x09, 0x90, 0xa4, 0x4d, 0xd2, 0x92,
>- 0x9e, 0xd3, 0x83, 0x6b, 0x62, 0x00, 0x00, 0x10, 0x22, 0xff, 0x7f, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x30, 0x42, 0x04, 0x92, 0x24, 0x6b, 0x53, 0x32,
>- 0x59, 0x90, 0x16, 0xfa, 0xb4, 0xf4, 0xff, 0x0f, 0x01, 0x00, 0x90, 0x68,
>- 0x4a, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x90, 0x24, 0x11, 0x24,
>- 0x49, 0xda, 0x82, 0xc5, 0x92, 0xd2, 0xd0, 0x9e, 0x1e, 0x00, 0x78, 0x0a,
>- 0x00, 0x00, 0x05, 0xd2, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x02,
>- 0x44, 0xb2, 0x65, 0xea, 0x49, 0x9e, 0x2c, 0x4b, 0x1a, 0xd2, 0xeb, 0xe3,
>- 0xff, 0xc7, 0x09, 0x00, 0x20, 0x68, 0xff, 0xd6, 0x01, 0x00, 0x00, 0x00,
>- 0x00, 0x0b, 0x90, 0x40, 0x92, 0x24, 0x09, 0x5f, 0xd2, 0x64, 0x59, 0x72,
>- 0x56, 0x7f, 0xfd, 0xdf, 0x1f, 0x12, 0x00, 0x20, 0x49, 0x92, 0xde, 0x01,
>- 0x00, 0x00, 0x00, 0x80, 0x41, 0x92, 0x4c, 0x92, 0x24, 0x25, 0xc9, 0x8b,
>- 0x2e, 0xcb, 0x92, 0x4b, 0x5a, 0x2f, 0x75, 0xf4, 0x04, 0x00, 0x00, 0x41,
>- 0xf6, 0x74, 0x01, 0x00, 0x00, 0x00, 0x40, 0x49, 0x02, 0x00, 0xba, 0xb6,
>- 0xfd, 0x49, 0xf8, 0x74, 0x6d, 0x4b, 0x72, 0xed, 0xdb, 0xff, 0xcf, 0x53,
>- 0x00, 0x00, 0x48, 0xb6, 0xd7, 0x03, 0x00, 0x00, 0x00, 0x60, 0x48, 0x10,
>- 0xc9, 0x93, 0x24, 0x00, 0x7b, 0xc3, 0xa6, 0x69, 0x58, 0x5a, 0xfb, 0xfa,
>- 0xa5, 0xbe, 0x16, 0x00, 0x00, 0x92, 0xa4, 0xfd, 0x03, 0x00, 0x00, 0x00,
>- 0x30, 0x01, 0x20, 0x5d, 0xa2, 0xfe, 0x7f, 0x01, 0x4f, 0x1a, 0xcd, 0x6b,
>- 0x6a, 0xa9, 0x5f, 0xff, 0xf3, 0x24, 0x01, 0x40, 0xc0, 0xb4, 0xf4, 0x03,
>- 0x00, 0x00, 0x00, 0x2c, 0x88, 0x84, 0x89, 0xb6, 0x00, 0x24, 0x7d, 0x69,
>- 0xf2, 0x34, 0xad, 0x99, 0x2d, 0xf7, 0xff, 0x9f, 0x4b, 0x00, 0x00, 0x92,
>- 0xa6, 0xad, 0x07, 0x00, 0x00, 0x00, 0x06, 0x91, 0x24, 0xe9, 0xa4, 0xfd,
>- 0xa5, 0xa9, 0x4b, 0x93, 0xe7, 0x34, 0x63, 0xf9, 0xfc, 0xd5, 0xef, 0x16,
>- 0x00, 0x40, 0x90, 0xb4, 0xbd, 0x07, 0x00, 0x00, 0x00, 0x6a, 0x80, 0x4c,
>- 0x96, 0xbe, 0x2d, 0xfd, 0x2f, 0x7c, 0x5e, 0x9c, 0x67, 0xad, 0xa5, 0xfd,
>- 0xff, 0xbf, 0x29, 0x00, 0x00, 0x92, 0x76, 0xed, 0x06, 0x00, 0x00, 0x00,
>- 0x05, 0x12, 0x48, 0x53, 0x25, 0x65, 0x25, 0xf4, 0xe5, 0xd3, 0x72, 0x9c,
>- 0x35, 0xdf, 0xf6, 0x7f, 0xf5, 0x56, 0x00, 0x00, 0x92, 0xa4, 0xed, 0x0f,
>- 0x00, 0x00, 0x80, 0x49, 0x20, 0x59, 0x38, 0xec, 0xff, 0xff, 0xad, 0x2f,
>- 0x5d, 0xd3, 0x33, 0xe6, 0x24, 0xed, 0xff, 0xdf, 0x2d, 0x01, 0x40, 0x80,
>- 0x24, 0xbd, 0x07, 0x00, 0x00, 0xc0, 0x48, 0x24, 0x49, 0x87, 0x37, 0x21,
>- 0xa0, 0xbd, 0xf4, 0x79, 0x4f, 0xc7, 0x9c, 0xde, 0xf6, 0xff, 0xff, 0x5b,
>- 0x08, 0x00, 0x92, 0xfc, 0xe9, 0x0e, 0x00, 0x00, 0x20, 0x89, 0x40, 0xd3,
>- 0xf4, 0x49, 0xff, 0xff, 0xe7, 0x2f, 0xcf, 0x79, 0x9c, 0x53, 0xb2, 0x35,
>- 0xff, 0xff, 0x37, 0x00, 0x40, 0x90, 0x24, 0xef, 0x0e, 0x00, 0x00, 0x30,
>- 0x91, 0x49, 0x32, 0x2d, 0xff, 0x6b, 0xb7, 0xbd, 0xbc, 0x3c, 0xef, 0x79,
>- 0xce, 0xde, 0xd6, 0xfd, 0xff, 0x9f, 0x00, 0x00, 0x92, 0xa6, 0xad, 0x0b,
>- 0x00, 0x00, 0x30, 0x11, 0x89, 0x8c, 0xcb, 0x5b, 0xba, 0xaf, 0xf6, 0xd7,
>- 0xe7, 0x35, 0xe7, 0x59, 0xb3, 0xfb, 0xff, 0xff, 0x7f, 0x04, 0x40, 0x80,
>- 0xe4, 0xb9, 0x1f, 0x00, 0x00, 0x48, 0x22, 0x91, 0x66, 0x79, 0xeb, 0xff,
>- 0xff, 0xdf, 0xbe, 0xbe, 0xe7, 0x8c, 0x75, 0x6b, 0x4a, 0xfa, 0xbf, 0x7f,
>- 0x00, 0x00, 0x82, 0x24, 0xef, 0x0e, 0x00, 0x00, 0x4c, 0x22, 0xb2, 0x79,
>- 0x5e, 0xfa, 0x5b, 0xa9, 0xfd, 0xeb, 0xf5, 0x9c, 0x3d, 0xc6, 0xcc, 0xee,
>- 0xed, 0x01, 0xf8, 0x00, 0x40, 0x82, 0xb6, 0xa9, 0x1b, 0x00, 0x00, 0x94,
>- 0x64, 0x66, 0x8e, 0xd3, 0x97, 0xfe, 0xff, 0xd7, 0xdf, 0x9f, 0x7b, 0xf3,
>- 0x3c, 0x35, 0x59, 0x6b, 0x00, 0x70, 0x00, 0x00, 0x40, 0xe4, 0xed, 0x1e,
>- 0x00, 0x00, 0x92, 0xc4, 0x34, 0xf3, 0xfc, 0xfd, 0x5f, 0xad, 0x7d, 0xfa,
>- 0x7a, 0xce, 0x8e, 0xb3, 0x76, 0x2f, 0xfd, 0x00, 0xe0, 0x04, 0x00, 0x9a,
>- 0x26, 0xaf, 0x1e, 0x00, 0x00, 0x13, 0x88, 0xcc, 0xb5, 0x3f, 0xbf, 0xff,
>- 0xff, 0xd7, 0xef, 0xef, 0xbd, 0x79, 0x6a, 0xde, 0xec, 0xab, 0x01, 0xc0,
>- 0x00, 0x00, 0x40, 0xb6, 0xbd, 0x1b, 0x00, 0x00, 0x05, 0x91, 0xeb, 0x5c,
>- 0xeb, 0xeb, 0xff, 0xff, 0xff, 0x7e, 0xef, 0x6b, 0xef, 0xcd, 0x99, 0xb3,
>- 0xe4, 0x07, 0x80, 0x00, 0x40, 0x49, 0xb2, 0xe5, 0x1a, 0x00, 0x80, 0x20,
>- 0x32, 0xb1, 0xe7, 0x79, 0x7f, 0xf7, 0xff, 0xfd, 0xeb, 0xbd, 0xfe, 0x2c,
>- 0x3d, 0x6b, 0xb6, 0xaf, 0x06, 0x80, 0x00, 0x00, 0x41, 0x96, 0xfe, 0x1e,
>- 0x00, 0x80, 0x44, 0xb2, 0x9b, 0xf9, 0xde, 0xff, 0xff, 0xff, 0x7f, 0xbf,
>- 0xf7, 0xbb, 0xb3, 0x77, 0xce, 0xce, 0xb6, 0x0d, 0x80, 0x01, 0x00, 0x49,
>- 0xf2, 0x94, 0x1f, 0x00, 0x40, 0x49, 0x44, 0xe6, 0x9e, 0x77, 0xff, 0xff,
>- 0xff, 0xff, 0xff, 0xbf, 0xf7, 0x7e, 0xd6, 0xbc, 0xd9, 0xba, 0x3b, 0x80,
>- 0x00, 0x00, 0x64, 0x93, 0xf7, 0x1b, 0x00, 0x40, 0x89, 0xec, 0x7e, 0x67,
>- 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0xdb, 0x99, 0x33, 0x37,
>- 0xd3, 0x36, 0x80, 0x01, 0x80, 0x24, 0xda, 0xd6, 0x1e, 0x00, 0x20, 0x90,
>- 0x99, 0x99, 0x7b, 0xef, 0xfb, 0xff, 0xff, 0xff, 0xff, 0xef, 0xbd, 0x37,
>- 0x63, 0xf3, 0x66, 0xdb, 0x7a, 0x80, 0x00, 0x00, 0x24, 0x59, 0xde, 0x1f,
>- 0x00, 0x60, 0x12, 0xb3, 0xf7, 0xdd, 0xfb, 0xfe, 0xff, 0xff, 0xff, 0xff,
>- 0xbf, 0xf7, 0xfe, 0x6e, 0xce, 0xdd, 0x6d, 0xd7, 0x80, 0x00, 0x80, 0x20,
>- 0xcb, 0xfb, 0x1f, 0x00, 0x10, 0x20, 0x6e, 0x66, 0x76, 0xff, 0xff, 0xff,
>- 0xff, 0xff, 0xff, 0xef, 0xde, 0xdb, 0x9b, 0x99, 0xb3, 0x5d, 0x6b, 0x81,
>- 0x00, 0x40, 0x96, 0x59, 0x6a, 0x1f, 0x00, 0x98, 0xc4, 0xe4, 0xdf, 0xff,
>- 0xfb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7b, 0x6f, 0x7b, 0x37, 0x7f,
>- 0xb3, 0xdd, 0x83, 0x00, 0x00, 0xb0, 0xed, 0xef, 0x1d, 0x00, 0x10, 0x88,
>- 0x9e, 0xdd, 0xcd, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xed,
>- 0x6c, 0xe6, 0xcc, 0x76, 0x6d, 0xc1, 0x00, 0x40, 0x91, 0x24, 0x7b, 0x1f,
>- 0x00, 0x08, 0xd1, 0xf1, 0x66, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
>- 0xff, 0xdf, 0xbd, 0xbf, 0xd9, 0xdd, 0xdd, 0xb6, 0x47, 0x00, 0x00, 0xd8,
>- 0xb4, 0xad, 0x1f, 0x00, 0x24, 0x24, 0x6f, 0xf6, 0xff, 0xff, 0xff, 0xff,
>- 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0xb7, 0x9d, 0x33, 0xd9, 0x96, 0x4e,
>- 0x00, 0x20, 0x49, 0xf7, 0xfd, 0x1e, 0x00, 0x48, 0xe4, 0xac, 0xb9, 0xdd,
>- 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xdd, 0x76, 0xb6,
>- 0xb7, 0xfd, 0x7a, 0x00, 0x00, 0x44, 0x96, 0xb7, 0x1f, 0x00, 0x02, 0x9a,
>- 0xbe, 0x6f, 0x77, 0xff, 0xff, 0x7f, 0x61, 0xd9, 0xff, 0xff, 0xff, 0xfd,
>- 0xdd, 0x66, 0xed, 0x66, 0x5b, 0x37, 0x00, 0x90, 0x64, 0xb9, 0xf6, 0x1f,
>- 0x00, 0x02, 0xc9, 0xf3, 0xee, 0xfd, 0xff, 0xff, 0x2f, 0x24, 0x4f, 0xfe,
>- 0xff, 0xff, 0x7f, 0x37, 0xdb, 0xcd, 0x7c, 0xff, 0x3a, 0x00, 0x88, 0x24,
>- 0xdb, 0xde, 0x1a, 0x00, 0x13, 0x31, 0x6f, 0xbb, 0xdf, 0xff, 0xff, 0x21,
>- 0xa0, 0x64, 0xf3, 0xff, 0xff, 0xe7, 0xff, 0x96, 0xbb, 0x9b, 0xa5, 0x1d,
>- 0x00, 0x60, 0x32, 0xe9, 0xdb, 0x0f, 0x00, 0x65, 0xe6, 0x3c, 0xfb, 0xf6,
>- 0xff, 0x7f, 0x10, 0xa4, 0xb5, 0x9d, 0xfe, 0xdf, 0xdf, 0xdd, 0x6d, 0x32,
>- 0xb3, 0x7d, 0x0d, 0x00, 0x0b, 0x93, 0x7c, 0x7b, 0x0f, 0x00, 0x89, 0xdc,
>- 0xb3, 0xed, 0xfb, 0xff, 0x1f, 0x10, 0x90, 0x92, 0xd9, 0xfe, 0x7f, 0xff,
>- 0x77, 0xdb, 0xee, 0x6e, 0xdb, 0x0e, 0x00, 0x20, 0xdd, 0x66, 0x6f, 0x0f,
>- 0x80, 0x91, 0x5a, 0xfb, 0xbe, 0xef, 0xff, 0x0f, 0x10, 0xda, 0x92, 0xee,
>- 0xff, 0xff, 0xff, 0xf7, 0xb7, 0xcd, 0xee, 0xde, 0x07, 0x00, 0x24, 0x49,
>- 0xb6, 0xed, 0x0f, 0x00, 0x12, 0x6b, 0xcd, 0xf3, 0xbe, 0xff, 0x07, 0x08,
>- 0x48, 0xda, 0x76, 0xb7, 0xff, 0xff, 0xdd, 0x6e, 0xba, 0x99, 0x65, 0x03,
>- 0x40, 0x92, 0xe4, 0xba, 0xbd, 0x0e, 0x80, 0x62, 0xed, 0x7d, 0x5f, 0xf7,
>- 0xff, 0x01, 0x08, 0x28, 0xc9, 0x26, 0xbb, 0xff, 0xff, 0xff, 0x99, 0xb7,
>- 0xbb, 0x7d, 0x03, 0x00, 0x89, 0x64, 0xdb, 0xf6, 0x07, 0x40, 0x0c, 0x35,
>- 0xe7, 0x79, 0xdd, 0xff, 0x01, 0x84, 0xa5, 0x7d, 0xba, 0xdd, 0xfe, 0x7f,
>- 0xbf, 0xbf, 0x6d, 0x76, 0xdb, 0x01, 0x00, 0x48, 0x36, 0xdb, 0xd6, 0x07,
>- 0xc0, 0x88, 0xb4, 0xb6, 0xbf, 0xff, 0x7f, 0x00, 0x0c, 0x24, 0x44, 0xdb,
>- 0xed, 0xff, 0xdf, 0xef, 0x6e, 0xdb, 0x6e, 0xb7, 0x00, 0x80, 0x44, 0x93,
>- 0xed, 0x5b, 0x07, 0x40, 0x91, 0xd2, 0xfa, 0xfc, 0xf6, 0x7f, 0x00, 0x02,
>- 0xb4, 0x35, 0xd9, 0xef, 0xff, 0xff, 0xfb, 0xef, 0xb6, 0xc9, 0xe4, 0x00,
>- 0x10, 0x24, 0xd9, 0x6d, 0xfb, 0x03, 0x00, 0x27, 0xfe, 0xd3, 0xd6, 0xdb,
>- 0x3f, 0x00, 0xa2, 0x94, 0xb4, 0xdb, 0x7c, 0xff, 0xff, 0xbf, 0xd9, 0xad,
>- 0xdb, 0x7d, 0x00, 0x40, 0x32, 0xd9, 0xb6, 0xef, 0x03, 0x60, 0xe4, 0x5a,
>- 0x5f, 0x5f, 0xff, 0x1f, 0x00, 0x02, 0x52, 0x92, 0xec, 0xb6, 0xff, 0xff,
>- 0xef, 0xff, 0x6d, 0xb6, 0x3b, 0x00, 0x28, 0x90, 0xcc, 0xbe, 0xfd, 0x03,
>- 0xa0, 0x88, 0xeb, 0xf9, 0xfd, 0xf5, 0x1f, 0x00, 0x82, 0x53, 0xbb, 0x6d,
>- 0xf7, 0xff, 0xf9, 0xff, 0x6f, 0xdb, 0x6d, 0x1b, 0x00, 0x04, 0xc9, 0x66,
>- 0xdb, 0x57, 0x03, 0xa0, 0x52, 0xaf, 0xa7, 0x97, 0xff, 0x0f, 0x00, 0x51,
>- 0x48, 0xda, 0x66, 0xdb, 0xff, 0xf8, 0xdf, 0xed, 0xbe, 0xed, 0x0e, 0x00,
>- 0x92, 0x64, 0x32, 0xeb, 0xf6, 0x01, 0x20, 0x63, 0xbd, 0xbc, 0xfc, 0xfa,
>- 0x0f, 0x00, 0x09, 0x20, 0x89, 0x3e, 0xff, 0xff, 0xe0, 0x7f, 0xdf, 0x6f,
>- 0xdb, 0x07, 0x00, 0x01, 0x24, 0xbb, 0xed, 0xfe, 0x01, 0xa0, 0xce, 0xf5,
>- 0xf6, 0xdb, 0xdf, 0x07, 0x00, 0x41, 0xad, 0x5f, 0xf2, 0xed, 0xff, 0xc0,
>- 0xff, 0xbf, 0xdd, 0x92, 0x03, 0x00, 0x44, 0xb2, 0xd9, 0x7d, 0xfb, 0x01,
>- 0xe0, 0xaa, 0xdf, 0x9b, 0x7f, 0xfb, 0x07, 0x80, 0x28, 0x21, 0x64, 0xbb,
>- 0x7f, 0x7f, 0x80, 0xff, 0xf6, 0xbb, 0xee, 0x03, 0x80, 0x22, 0x99, 0xed,
>- 0xb6, 0xff, 0x00, 0x90, 0xb8, 0x5e, 0x5b, 0x6b, 0xed, 0x03, 0x00, 0x01,
>- 0xa6, 0x6d, 0xdb, 0xf6, 0x7f, 0x00, 0xff, 0xff, 0xf6, 0xcd, 0x00, 0x40,
>- 0x10, 0xc9, 0x6c, 0xff, 0xf7, 0x00, 0xa0, 0xe3, 0x72, 0xeb, 0xef, 0xff,
>- 0x03, 0x80, 0xe0, 0x90, 0x24, 0xdb, 0xbd, 0x3f, 0x00, 0xfe, 0xdb, 0x6f,
>- 0xfb, 0x00, 0x00, 0x89, 0x4c, 0xb6, 0xd9, 0x7e, 0x00, 0x70, 0xaf, 0xaf,
>- 0x6f, 0xb5, 0xde, 0x03, 0x80, 0x94, 0x92, 0xb6, 0xf9, 0xf6, 0x3f, 0x00,
>- 0xfc, 0xbf, 0xdd, 0x7b, 0x00, 0x10, 0x48, 0x26, 0xb3, 0xdf, 0x7f, 0x00,
>- 0x70, 0xd8, 0xae, 0xfd, 0xff, 0xf7, 0x03, 0x80, 0x00, 0xd2, 0x36, 0xcf,
>- 0xdf, 0x3f, 0x00, 0xb8, 0x6d, 0xdf, 0x16, 0x00, 0x48, 0x44, 0xb2, 0xfb,
>- 0x6c, 0x3f, 0x00, 0x50, 0x75, 0xfd, 0xa5, 0xd5, 0xfe, 0x01, 0x40, 0xd1,
>- 0x12, 0xa2, 0x7d, 0xfb, 0x1f, 0x00, 0xf0, 0xff, 0xbf, 0x0d, 0x00, 0x20,
>- 0x12, 0x9b, 0xcd, 0xf6, 0x3f, 0x00, 0x90, 0xd5, 0xa7, 0xfd, 0x77, 0xab,
>- 0x03, 0x40, 0x1c, 0xc8, 0xbe, 0x6d, 0xfb, 0x1f, 0x00, 0xe0, 0xff, 0xee,
>- 0x07, 0x00, 0x04, 0x91, 0xc9, 0x7e, 0xbf, 0x1f, 0x00, 0x30, 0x57, 0xbf,
>- 0xa6, 0xde, 0xfd, 0x01, 0x40, 0x40, 0x6b, 0xd3, 0x6e, 0xef, 0x0f, 0x00,
>- 0xc0, 0xeb, 0x7d, 0x03, 0x00, 0x90, 0xc8, 0x6c, 0x76, 0xfb, 0x0f, 0x00,
>- 0x70, 0x5c, 0xe5, 0xf7, 0xfa, 0xeb, 0x01, 0x40, 0x50, 0x49, 0x92, 0xf4,
>- 0xfd, 0x0f, 0x00, 0xc0, 0xff, 0xdb, 0x01, 0x80, 0x44, 0x44, 0x66, 0xbb,
>- 0x6f, 0x0f, 0x00, 0xd0, 0xf1, 0x95, 0xf6, 0x6f, 0xad, 0x01, 0x40, 0x08,
>- 0x78, 0xdb, 0xb6, 0xef, 0x0f, 0x00, 0x00, 0xdf, 0xd6, 0x00, 0x00, 0x20,
>- 0x32, 0xb3, 0xdb, 0xfd, 0x0f, 0x00, 0x10, 0xd7, 0xf7, 0xb6, 0xd8, 0xeb,
>- 0x03, 0x20, 0x43, 0x27, 0xd9, 0xb6, 0xfd, 0x0f, 0x00, 0x00, 0xff, 0x7e,
>- 0x00, 0x40, 0x12, 0x93, 0xd9, 0xec, 0xb6, 0x07, 0x00, 0x70, 0x55, 0xdd,
>- 0xf6, 0x6f, 0xbb, 0x01, 0x40, 0x28, 0xa1, 0x6f, 0xb6, 0xb7, 0x0f, 0x00,
>- 0x00, 0xde, 0x1f, 0x00, 0x80, 0x88, 0xd8, 0xcc, 0x66, 0xff, 0x03, 0x00,
>- 0x70, 0xf4, 0xf5, 0xdb, 0xaa, 0xee, 0x01, 0x60, 0x28, 0x2d, 0x49, 0xf7,
>- 0xf6, 0x07, 0x00, 0x00, 0x7c, 0x0f, 0x00, 0x08, 0x48, 0x66, 0x6e, 0xfb,
>- 0xef, 0x03, 0x00, 0xd0, 0xd5, 0xdf, 0x52, 0xff, 0xda, 0x03, 0x20, 0xa3,
>- 0xa5, 0xd9, 0xb2, 0xff, 0x07, 0x00, 0x00, 0xf8, 0x07, 0x00, 0x20, 0x22,
>- 0x33, 0x37, 0xbf, 0xfd, 0x01, 0x00, 0x70, 0x5f, 0xf7, 0xfe, 0xab, 0x6b,
>- 0x02, 0xa0, 0xa8, 0xb4, 0x6d, 0xdf, 0xf6, 0x07, 0x00, 0x00, 0xf8, 0x01,
>- 0x00, 0x12, 0x33, 0x11, 0xd9, 0xdd, 0xff, 0x01, 0x00, 0x70, 0x75, 0xd5,
>- 0x52, 0xea, 0x8a, 0x03, 0x20, 0x84, 0x36, 0x69, 0xba, 0xdb, 0x07, 0x00,
>- 0x00, 0xf0, 0x01, 0x00, 0x81, 0xc8, 0xcc, 0xdd, 0xed, 0xff, 0x00, 0x00,
>- 0x60, 0xd5, 0xdf, 0xf6, 0xae, 0x6b, 0x03, 0x00, 0xa1, 0xa4, 0x6d, 0xdf,
>- 0xfe, 0x07, 0x00, 0x00, 0x60, 0x00, 0x40, 0x44, 0xc6, 0xcc, 0x64, 0xb7,
>- 0xfd, 0x00, 0x00, 0xe0, 0x55, 0xf7, 0xd6, 0xea, 0xba, 0x07, 0x20, 0x94,
>- 0x94, 0x6d, 0xfb, 0xdb, 0x07, 0x00, 0x00, 0x20, 0x00, 0x20, 0x20, 0x32,
>- 0x76, 0x77, 0xff, 0x7f, 0x00, 0x00, 0x60, 0x7d, 0xd5, 0xb6, 0x3f, 0xaf,
>- 0x06, 0xa0, 0xa4, 0x95, 0x6c, 0x9b, 0xee, 0x07, 0x00, 0x00, 0x18, 0x00,
>- 0x10, 0x92, 0x15, 0x73, 0xbb, 0xd9, 0x3f, 0x00, 0x00, 0xe0, 0xf5, 0xff,
>- 0xf7, 0x6a, 0xa9, 0x06, 0x80, 0xa2, 0xb4, 0x6d, 0xfb, 0xfb, 0x07, 0x00,
>- 0x00, 0x04, 0x00, 0x84, 0x88, 0xc8, 0x99, 0xdd, 0xff, 0x3f, 0x00, 0x00,
>- 0xe0, 0x8b, 0xff, 0x96, 0x6a, 0xb6, 0x0a, 0xa0, 0x94, 0x96, 0x64, 0xdb,
>- 0xee, 0x07, 0x00, 0x00, 0x03, 0x08, 0x20, 0x60, 0x66, 0xec, 0xee, 0xb6,
>- 0x1d, 0x00, 0x00, 0xc0, 0x7e, 0xa5, 0xf4, 0xab, 0x55, 0x0d, 0x20, 0xe7,
>- 0xd4, 0x6d, 0xdb, 0xfb, 0x07, 0x00, 0x80, 0x00, 0x00, 0x09, 0x12, 0x33,
>- 0x67, 0x77, 0xff, 0x0f, 0x00, 0x00, 0xc0, 0xfa, 0xff, 0xb7, 0x7a, 0x55,
>- 0x19, 0x90, 0x91, 0xd4, 0x64, 0xdb, 0xee, 0x07, 0x00, 0x40, 0x00, 0x81,
>- 0x04, 0x88, 0x91, 0x3b, 0xbb, 0xfd, 0x0f, 0x00, 0x00, 0xc0, 0xab, 0xbf,
>- 0xed, 0x4e, 0xbb, 0x32, 0x20, 0x94, 0x96, 0x6c, 0xff, 0xfa, 0x03, 0x00,
>- 0x30, 0x40, 0x20, 0x20, 0x64, 0xcc, 0xdc, 0xdd, 0xff, 0x07, 0x00, 0x00,
>- 0xc0, 0xeb, 0xea, 0xfd, 0xd5, 0xaa, 0x2a, 0x20, 0xd7, 0xb0, 0x6d, 0x93,
>- 0xef, 0x07, 0x00, 0x08, 0x00, 0x08, 0x01, 0x23, 0xee, 0xee, 0xee, 0xfb,
>- 0x03, 0x00, 0x00, 0xc0, 0xfe, 0xff, 0x2d, 0xdd, 0x6a, 0x49, 0xd0, 0x90,
>- 0x9a, 0x64, 0xdf, 0xea, 0x07, 0x00, 0x03, 0x80, 0x40, 0x8c, 0x98, 0x33,
>- 0xb3, 0xbb, 0xff, 0x01, 0x00, 0x00, 0xc0, 0xa5, 0x7b, 0x6d, 0xa7, 0x56,
>- 0xc5, 0xa0, 0x94, 0x94, 0x6f, 0xd3, 0xbb, 0x07, 0x80, 0x10, 0x0c, 0x12,
>- 0x40, 0xc6, 0xb9, 0xdb, 0xfb, 0xfd, 0x01, 0x00, 0x00, 0x80, 0x97, 0xee,
>- 0xdf, 0xba, 0x54, 0x1a, 0xa1, 0xe5, 0xd2, 0x64, 0x7e, 0xee, 0x07, 0x60,
>- 0x02, 0x80, 0x00, 0x31, 0x62, 0xcc, 0xdc, 0xee, 0x7f, 0x00, 0x00, 0x00,
>- 0x80, 0xff, 0xff, 0xdb, 0xaa, 0xb5, 0x8a, 0x86, 0x98, 0x96, 0x6d, 0x9b,
>- 0xea, 0x07, 0x98, 0x00, 0x22, 0x44, 0x88, 0x39, 0x77, 0x77, 0xff, 0x7f,
>- 0x00, 0x00, 0x00, 0x80, 0x7d, 0x77, 0xba, 0x7b, 0x2d, 0x55, 0x3c, 0xa6,
>- 0xb4, 0x6c, 0xf6, 0xaf, 0x07, 0x07, 0x90, 0x88, 0x20, 0x42, 0x9c, 0xbb,
>- 0xbb, 0xbb, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x4b, 0xbd, 0xbf, 0x55, 0x53,
>- 0xa5, 0xb2, 0xa1, 0xb4, 0xc9, 0x9f, 0xda, 0xcf, 0x28, 0x24, 0x42, 0x08,
>- 0x31, 0xe6, 0xcc, 0xdd, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xef,
>- 0xb7, 0xbd, 0xde, 0x12, 0xd1, 0xac, 0x95, 0x4d, 0xf2, 0x56, 0x9f, 0x88,
>- 0x80, 0x10, 0xc2, 0x9c, 0x73, 0x77, 0xef, 0xfe, 0x7f, 0x00, 0x00, 0x00,
>- 0x00, 0xbf, 0xfb, 0xed, 0xeb, 0x35, 0x95, 0x72, 0xa2, 0x35, 0xcd, 0xb6,
>- 0xd6, 0x2f, 0x21, 0x24, 0x04, 0x31, 0xc6, 0x98, 0x33, 0xf7, 0xff, 0xff,
>- 0x00, 0x00, 0x00, 0x00, 0xd6, 0x6a, 0x7f, 0x5b, 0xab, 0x2d, 0x28, 0x23,
>- 0x65, 0xd9, 0xb6, 0x55, 0x5f, 0x88, 0x08, 0x43, 0x0c, 0x61, 0xde, 0xdd,
>- 0xfb, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0x4d, 0xd7, 0x4d,
>- 0x4a, 0xa5, 0x29, 0x2d, 0xdb, 0xbe, 0x55, 0x1f, 0x22, 0x42, 0x28, 0xc2,
>- 0x39, 0xe7, 0xee, 0xee, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x7f,
>- 0xfb, 0xb6, 0xb6, 0x95, 0x70, 0x2e, 0xa5, 0xd9, 0x24, 0x5d, 0x5f, 0x8a,
>- 0x28, 0x88, 0x31, 0x9e, 0x39, 0x73, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
>- 0x00, 0xec, 0xb7, 0xdf, 0x6c, 0xb5, 0x65, 0x26, 0xa3, 0x39, 0x9b, 0xfc,
>- 0x85, 0x5d, 0x21, 0x04, 0x63, 0x1c, 0xe6, 0xdd, 0xbd, 0xfb, 0xff, 0xff,
>- 0x01, 0x00, 0x00, 0x00, 0xb8, 0xfa, 0xb6, 0x6f, 0x4d, 0x9a, 0x28, 0x59,
>- 0x4d, 0xd3, 0x2f, 0xf5, 0x3f, 0x8c, 0xd1, 0x18, 0xc6, 0x31, 0xf6, 0xdd,
>- 0xfe, 0xff, 0xfe, 0x01, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xef, 0xb9, 0xb6,
>- 0x25, 0xe1, 0x4d, 0x69, 0xba, 0x6c, 0xad, 0x3c, 0x41, 0x14, 0x84, 0xe9,
>- 0x9e, 0x37, 0xf7, 0xff, 0xff, 0xfb, 0x03, 0x00, 0x00, 0x00, 0x70, 0x5d,
>- 0x3d, 0x9f, 0x3d, 0x6d, 0x26, 0x52, 0x59, 0xb6, 0x6d, 0xab, 0x7f, 0x14,
>- 0x82, 0xe1, 0x39, 0xe6, 0xdd, 0xfb, 0xff, 0xbf, 0xff, 0x01, 0x00, 0x00,
>- 0x00, 0xf0, 0xf6, 0x6f, 0x77, 0xcd, 0x92, 0xd0, 0x52, 0x4b, 0xb3, 0x49,
>- 0x0b, 0x3a, 0x41, 0x61, 0x38, 0x9e, 0x73, 0xee, 0xdc, 0xff, 0xff, 0xfd,
>- 0x03, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xd7, 0x65, 0xda, 0x66, 0x63, 0x9d,
>- 0xf2, 0x36, 0x7b, 0x6a, 0x7f, 0x14, 0x18, 0x8e, 0xe7, 0xd9, 0x7b, 0xff,
>- 0xff, 0xef, 0xff, 0x03, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xdd, 0xb6,
>- 0xc9, 0x4c, 0x46, 0x9a, 0x64, 0xcb, 0x5b, 0xed, 0x06, 0xc6, 0xe3, 0x71,
>- 0xde, 0xbd, 0xff, 0xff, 0x7f, 0xff, 0x07, 0x00, 0x00, 0x00, 0xc0, 0x7f,
>- 0x7f, 0xff, 0x59, 0x37, 0x75, 0xbb, 0x96, 0x66, 0xdb, 0x56, 0xf7, 0xe0,
>- 0xf2, 0x74, 0x9e, 0x77, 0xef, 0xfd, 0xff, 0xeb, 0xed, 0x03, 0x00, 0x00,
>- 0x00, 0xc0, 0xea, 0xdf, 0xb3, 0xdb, 0xde, 0xc6, 0x81, 0xb0, 0x6c, 0xba,
>- 0xb4, 0xf6, 0x38, 0x18, 0x3c, 0xe7, 0x9c, 0xfb, 0xff, 0x7f, 0xff, 0xff,
>- 0x07, 0x00, 0x00, 0x00, 0x80, 0xff, 0xf7, 0x6e, 0x66, 0xd9, 0x99, 0xac,
>- 0xa4, 0xcd, 0x96, 0xa5, 0xea, 0x03, 0xa7, 0xcf, 0x79, 0xef, 0xfd, 0xff,
>- 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xef, 0xdf,
>- 0x6f, 0xef, 0x72, 0x65, 0xd9, 0xb6, 0xad, 0xe8, 0xc1, 0xe1, 0xf1, 0xbe,
>- 0x7b, 0xef, 0xff, 0xdf, 0x7a, 0xfb, 0x07, 0x00, 0x00, 0x00, 0x00, 0xfe,
>- 0x5f, 0xdd, 0x9d, 0xac, 0x99, 0x84, 0x29, 0xcd, 0x3c, 0x4f, 0x9d, 0x7d,
>- 0x3c, 0x9e, 0xe7, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xef, 0x0f, 0x00, 0x00,
>- 0x00, 0x00, 0xfe, 0xff, 0x77, 0x7b, 0x33, 0xe7, 0x5a, 0x49, 0x9b, 0x65,
>- 0x59, 0x75, 0x07, 0x97, 0xf7, 0xbb, 0xef, 0xff, 0xff, 0xdb, 0xfe, 0xff,
>- 0x07, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xf7, 0x3f, 0xe7, 0xcf, 0x9c, 0x51,
>- 0x4d, 0xb0, 0x6d, 0x4b, 0xc9, 0xd3, 0xf5, 0x79, 0xfe, 0xfb, 0xff, 0xff,
>- 0xdb, 0xda, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xef, 0xde,
>- 0xdd, 0xf3, 0x4d, 0x52, 0x36, 0xcb, 0xd2, 0x3a, 0x7e, 0x3c, 0xde, 0xe7,
>- 0xbe, 0xff, 0x7f, 0xda, 0xff, 0xdf, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xf8,
>- 0xff, 0xfb, 0xdd, 0x73, 0x8f, 0xa5, 0x9a, 0xe6, 0xd9, 0xb6, 0xe2, 0x4e,
>- 0xc7, 0xf7, 0xfd, 0xff, 0xff, 0xff, 0xf7, 0xf6, 0xff, 0x0f, 0x00, 0x00,
>- 0x00, 0x00, 0xe0, 0xff, 0xff, 0x7f, 0xee, 0x79, 0xb2, 0xb2, 0x2c, 0x9f,
>- 0xb6, 0x54, 0xfe, 0xfb, 0x79, 0xbf, 0xff, 0xff, 0x5f, 0xda, 0xff, 0xfa,
>- 0x0f, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xf7, 0xbf, 0xe7, 0x4b,
>- 0xb4, 0x69, 0xd3, 0x2c, 0x25, 0xbd, 0xbc, 0xcf, 0xf7, 0xfd, 0xff, 0xd7,
>- 0xf6, 0xfe, 0xdf, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xbf, 0x9d,
>- 0xf1, 0x3e, 0x57, 0x25, 0xcb, 0xb6, 0x6d, 0xa9, 0xb5, 0xef, 0xfb, 0xff,
>- 0xff, 0xff, 0xd5, 0xda, 0xd6, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x80,
>- 0xff, 0xff, 0xfb, 0xcf, 0xf5, 0x25, 0x65, 0xd9, 0x66, 0x5b, 0x4a, 0xfa,
>- 0xf9, 0x7e, 0xff, 0xff, 0xff, 0xf6, 0xd6, 0xdf, 0xfa, 0x0f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0xfe, 0xff, 0xef, 0x3e, 0xf7, 0x9f, 0x5b, 0x92, 0x6c,
>- 0xdb, 0x52, 0xe5, 0xbe, 0xdf, 0xff, 0xff, 0xbf, 0x51, 0xda, 0xfa, 0x7f,
>- 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x7b, 0x9f, 0xe7,
>- 0x4c, 0xb3, 0x4d, 0xd3, 0x54, 0xd9, 0xe7, 0xfb, 0xff, 0xff, 0x5f, 0xdc,
>- 0xfa, 0xdf, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x7f,
>- 0xe7, 0xf9, 0x3a, 0xd3, 0xa6, 0xe9, 0xb6, 0xa5, 0xca, 0xf9, 0xfd, 0xff,
>- 0xff, 0x83, 0x42, 0xd2, 0xff, 0xfb, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0xf0, 0xff, 0xfd, 0xbf, 0xef, 0x4f, 0xd5, 0x64, 0xdb, 0x26, 0x4d, 0x30,
>- 0x7f, 0xff, 0xff, 0xff, 0x91, 0xda, 0xdb, 0xda, 0xdf, 0x1f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0xe0, 0xff, 0xbf, 0xff, 0x7d, 0xbe, 0xb5, 0x6d, 0x97,
>- 0x6d, 0x93, 0x56, 0xdf, 0xff, 0xff, 0x7f, 0x81, 0x4a, 0xda, 0x7f, 0xff,
>- 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xef, 0xeb, 0xbb,
>- 0xa6, 0x4d, 0x73, 0xcd, 0x92, 0xaa, 0xfe, 0xff, 0xff, 0x1f, 0x01, 0x6a,
>- 0x5b, 0xfb, 0xfb, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
>- 0xfd, 0xbf, 0x5f, 0x3b, 0xdb, 0x36, 0xbb, 0x26, 0x4c, 0xf9, 0xff, 0xff,
>- 0x0f, 0xa3, 0x2a, 0xe9, 0x7f, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xee, 0xff, 0xff, 0xfe, 0xfe, 0xcc, 0x91, 0xec, 0x93, 0x6d, 0x93,
>- 0xf2, 0xff, 0xff, 0x03, 0x00, 0x6a, 0x6d, 0x6f, 0xff, 0x1f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xf7, 0x6f, 0x76, 0xb6, 0xcd,
>- 0x76, 0xc9, 0x2a, 0xe9, 0xff, 0xff, 0x00, 0x02, 0x24, 0xed, 0xf9, 0xed,
>- 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xdf, 0xff,
>- 0xd9, 0x66, 0x9b, 0x6c, 0x93, 0x54, 0xc5, 0xff, 0x3f, 0x00, 0x01, 0x95,
>- 0xb5, 0xaf, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff,
>- 0xff, 0xff, 0xfd, 0xae, 0x7d, 0xde, 0x6d, 0xf6, 0xa1, 0x8a, 0xff, 0x0f,
>- 0x00, 0x81, 0x90, 0xb4, 0xfd, 0xfd, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xcd, 0xb2, 0xdb, 0x2c, 0xcb,
>- 0x54, 0xfe, 0x01, 0x00, 0x01, 0xd2, 0xb6, 0xb7, 0xff, 0x0f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x39, 0xdb, 0x76,
>- 0xb3, 0x4b, 0xb6, 0x0a, 0xfe, 0x00, 0x00, 0x01, 0x48, 0xda, 0xfe, 0xff,
>- 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff,
>- 0xcf, 0xb9, 0x6d, 0xb6, 0xd9, 0xa5, 0x75, 0x1c, 0x00, 0x80, 0x80, 0x20,
>- 0xdb, 0xda, 0xbe, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0,
>- 0xff, 0xff, 0xff, 0x77, 0x96, 0xd9, 0x26, 0xb3, 0x4d, 0x82, 0x11, 0x00,
>- 0x80, 0x80, 0x24, 0x6d, 0xff, 0xf7, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xbb, 0x67, 0xdb, 0xdd, 0x36, 0xd9,
>- 0x54, 0x60, 0x00, 0xc0, 0x00, 0x92, 0x65, 0x6b, 0xff, 0x0f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x4f, 0x7d, 0x96,
>- 0xd9, 0x6c, 0x36, 0xad, 0xc2, 0x00, 0x60, 0x00, 0xc8, 0xb6, 0x6d, 0xff,
>- 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff,
>- 0xff, 0xc8, 0x76, 0xbb, 0xcb, 0x64, 0x52, 0x02, 0x03, 0x10, 0x00, 0x64,
>- 0xda, 0xff, 0xfb, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x80, 0xff, 0xff, 0x5f, 0xd7, 0x4d, 0x33, 0x99, 0xdd, 0x96, 0x04, 0x2c,
>- 0x1c, 0x40, 0x22, 0xdb, 0xb6, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xdf, 0xb5, 0xed, 0xe6, 0x36, 0x9b,
>- 0x6c, 0x29, 0xf0, 0x03, 0x00, 0x99, 0x6c, 0xfb, 0xfd, 0x07, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x35, 0xbb,
>- 0xec, 0x76, 0x33, 0x91, 0x02, 0x00, 0x00, 0x00, 0x64, 0x67, 0xdf, 0xff,
>- 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc,
>- 0xbf, 0x6f, 0x9b, 0x9d, 0xc9, 0xce, 0x36, 0x49, 0x00, 0x00, 0x00, 0x93,
>- 0xb1, 0xdd, 0xfe, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x40, 0xff, 0x6a, 0x76, 0xbb, 0xdd, 0xd9, 0x64, 0x12, 0x01,
>- 0x00, 0x40, 0x98, 0xdd, 0x6d, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xdf, 0x66, 0x73, 0x33, 0xbb,
>- 0x9d, 0x4d, 0x00, 0x00, 0x00, 0x63, 0xe6, 0xf6, 0xff, 0x07, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xed, 0xfd,
>- 0xee, 0xee, 0x36, 0x73, 0x2b, 0x04, 0x00, 0xa0, 0x38, 0x75, 0xbf, 0xff,
>- 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x7f, 0xd9, 0xec, 0xce, 0x66, 0x66, 0x66, 0x22, 0x04, 0x00, 0xc6,
>- 0x99, 0xbb, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x5e, 0xb3, 0xdb, 0xb9, 0xcd, 0xc9, 0x88, 0x89,
>- 0x00, 0x68, 0x31, 0xee, 0xdd, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xbe, 0xbb, 0x9b, 0x3f,
>- 0xbb, 0x33, 0x23, 0x04, 0x00, 0x8c, 0xf3, 0xee, 0xff, 0x03, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbc, 0x67,
>- 0x76, 0x77, 0xb2, 0x66, 0xce, 0x0c, 0xd1, 0xd6, 0xe3, 0x79, 0xf7, 0xff,
>- 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xf8, 0xfd, 0xef, 0xe6, 0xee, 0xce, 0x9c, 0x31, 0x16, 0x00, 0x3c,
>- 0x9e, 0xfb, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x78, 0x9f, 0xdb, 0xdc, 0x9d, 0x99, 0x33, 0xc6,
>- 0xc1, 0xff, 0x8f, 0xe7, 0xbb, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf7, 0xbd, 0xbb, 0x33,
>- 0x7b, 0xee, 0x18, 0x1e, 0x50, 0xf0, 0xf9, 0xfe, 0xff, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7b,
>- 0xf7, 0x77, 0xf7, 0xe6, 0x9c, 0xe3, 0xf0, 0x4d, 0xff, 0x7c, 0xef, 0xff,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xc0, 0xdf, 0x76, 0x7f, 0xcf, 0x9e, 0x73, 0x8f, 0x07, 0xff, 0x0b,
>- 0xdf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x80, 0xee, 0xcd, 0xdd, 0x9d, 0x7b, 0xf7, 0x7c,
>- 0x7a, 0x00, 0xf0, 0xe7, 0xfd, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x7f, 0xbf, 0xdd, 0x7b,
>- 0x6b, 0x9e, 0xf3, 0xe1, 0xff, 0xff, 0x7d, 0xff, 0x7f, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xee,
>- 0xb7, 0xbb, 0x7b, 0xee, 0x79, 0x8f, 0x0f, 0xfa, 0x2f, 0xff, 0xf7, 0x3f,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x7e, 0xff, 0x77, 0xef, 0xdd, 0x77, 0x7c, 0xfe, 0x02, 0xe8,
>- 0xcf, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xef, 0xee, 0xdd, 0xb3, 0xcf, 0xf3,
>- 0xf1, 0xff, 0xff, 0xf9, 0xfe, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xfb, 0xff, 0xbf,
>- 0xef, 0xbe, 0xcf, 0x8f, 0xfe, 0x5f, 0xfe, 0xff, 0x0f, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0,
>- 0xbf, 0xbb, 0xf7, 0xde, 0x79, 0x3e, 0xff, 0x52, 0xd2, 0xdf, 0xff, 0x0f,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0xe0, 0xef, 0xef, 0xef, 0x3c, 0xef, 0xf9, 0xf8, 0xff, 0xff,
>- 0xf7, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xee, 0xdc, 0xf7, 0xfe, 0xe7,
>- 0x97, 0xfe, 0xff, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbf,
>- 0xef, 0xbf, 0x3e, 0xff, 0xda, 0xf6, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0xfe, 0xbf, 0xf7, 0xfe, 0xf7, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0xfe, 0xff, 0xde, 0xbd, 0xef, 0xfb, 0xd7, 0xff, 0xbf,
>- 0xfd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xf7, 0x7d, 0xbf,
>- 0xff, 0xd2, 0xf6, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xbf,
>- 0xef, 0xfb, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0xc0, 0xff, 0xef, 0xbe, 0xf7, 0xef, 0xef, 0xff, 0xff, 0xff, 0x3f, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfb, 0xdf, 0xbf, 0xff, 0xff, 0xff,
>- 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x7f, 0xff,
>- 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff,
>- 0xfe, 0xff, 0xfb, 0xf7, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0xf0, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xfd, 0xff, 0xff, 0x03, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
>- 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff,
>- 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe,
>- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
>- 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,
>- 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0xfc, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x07,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff,
>- 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
>- };
>-
>-# define GCBits	(GCFillStyle|GCTileStipXOrigin|GCTileStipYOrigin)
>-
>-void SetFillStyle(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    int	    xorg = 0, yorg = 0;
>-
>-    if (p->fillStyle == FillStippled || p->fillStyle == FillOpaqueStippled) {
>-	Pixmap      stipple;
>-	XGCValues   gcv;
>-
>-	if (!p->font) {
>-	    /* Little 8x8 stipple */
>-	    stipple = XCreateBitmapFromData(xp->d, xp->w, (char *)bitmap8x8, 8, 8);
>-	} else if (!strcmp (p->font, "escherknot")) {
>-	    /* Enormous stipple which is x4 bits wide */
>-	    stipple = XCreateBitmapFromData(xp->d, xp->w,
>-			(char *)escherknot_bits, escherknot_width, escherknot_height);
>-	    xorg = -3;
>-	} else if (!strcmp (p->font, "OddTile")) {
>-	    /* Odd sized tile */
>-	    stipple = XCreateBitmapFromData(xp->d, xp->w,
>-			(char *)oddbit_bits, oddbit_width, oddbit_height);
>-	} else {
>-	    /* Enormous stipple.  Well, pretty big. */
>-	    stipple = XCreateBitmapFromData(xp->d, xp->w,
>-		       (char *)mensetmanus_bits, mensetmanus_width, mensetmanus_height);
>-	}
>-
>-	gcv.stipple = stipple;
>-	gcv.fill_style = p->fillStyle;
>-	gcv.ts_x_origin = xorg;
>-	gcv.ts_y_origin = yorg;
>-	XChangeGC(xp->d, xp->fggc, GCBits | GCStipple, &gcv);
>-	XChangeGC(xp->d, xp->bggc, GCBits | GCStipple, &gcv);
>-	XFreePixmap(xp->d, stipple);
>-
>-    } else if (p->fillStyle == FillTiled) {
>-	Pixmap      tile;
>-	XGCValues   gcv;
>-
>-	gcv.fill_style = FillTiled;
>-	if (!p->font) {
>-	    /* Little 4x4 tile */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w, (char *)bitmap4x4, 4, 4,
>-		    xp->foreground, xp->background, xp->vinfo.depth);
>-	} else if (!strcmp (p->font, "escherknot")) {
>-	    /* Enormous stipple which is x4 bits wide */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w,
>-		    (char *)escherknot_bits, escherknot_width, escherknot_height,
>-		    xp->foreground, xp->background, xp->vinfo.depth);
>-	    /* align tile with screen */
>-	    xorg = -3;
>-	} else if (!strcmp (p->font, "OddTile")) {
>-	    /* Odd sized tile */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w,
>-		    (char *)oddbit_bits, oddbit_width, oddbit_height,
>-		    xp->foreground, xp->background, xp->vinfo.depth);
>-	    /* align tile with screen */
>-	} else {
>-	    /* Enormous tile.  Well, pretty big. */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w,
>-		    (char *)mensetmanus_bits, mensetmanus_width, mensetmanus_height,
>-		    xp->foreground, xp->background, xp->vinfo.depth);
>-	}
>-	gcv.tile = tile;
>-	gcv.ts_x_origin = xorg;
>-	gcv.ts_y_origin = yorg;
>-	XChangeGC(xp->d, xp->fggc, GCBits | GCTile, &gcv);
>-	XFreePixmap(xp->d, tile);
>-	if (!p->font) {
>-	    /* Little 4x4 tile */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w, (char *)bitmap4x4, 4, 4,
>-		    xp->background, xp->foreground, xp->vinfo.depth);
>-	} else if (!strcmp (p->font, "escherknot")) {
>-	    /* Enormous stipple which is x4 bits wide */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w,
>-		    (char *)escherknot_bits, escherknot_width, escherknot_height,
>-		    xp->background, xp->foreground, xp->vinfo.depth);
>-	} else if (!strcmp (p->font, "OddTile")) {
>-	    /* Odd sized tile */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w,
>-		    (char *)oddbit_bits, oddbit_width, oddbit_height,
>-		    xp->background, xp->foreground, xp->vinfo.depth);
>-	} else {
>-	    /* Enormous tile.  Well, pretty big. */
>-	    tile = XCreatePixmapFromBitmapData(xp->d, xp->w,
>-		    (char *)mensetmanus_bits, mensetmanus_width, mensetmanus_height,
>-		    xp->background, xp->foreground, xp->vinfo.depth);
>-	}
>-	gcv.tile = tile;
>-	XChangeGC(xp->d, xp->bggc, GCFillStyle | GCTile, &gcv);
>-	XFreePixmap(xp->d, tile);
>-    }
>-}
>Index: xc/programs/x11perf/bitmaps.h
>===================================================================
>RCS file: xc/programs/x11perf/bitmaps.h
>diff -N xc/programs/x11perf/bitmaps.h
>--- xc/programs/x11perf/bitmaps.h	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,31 +0,0 @@
>-/* $Xorg: bitmaps.h,v 1.3 2000/08/17 19:54:09 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-/* Set fill style (if any) to a bitmap or tile */
>-
>-extern void SetFillStyle(/* xp, p */);
>-/*
>-    XParms  xp;
>-    Parms   p;
>-*/
>Index: xc/programs/x11perf/do_arcs.c
>===================================================================
>RCS file: xc/programs/x11perf/do_arcs.c
>diff -N xc/programs/x11perf/do_arcs.c
>--- xc/programs/x11perf/do_arcs.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,555 +0,0 @@
>-/* $Xorg: do_arcs.c,v 1.3 2000/08/17 19:54:09 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-static XArc *arcs;
>-static GC   pgc;
>-
>-#define DegreesToX(degrees) (degrees * 64)
>-
>-static void GenerateCircles(xp, p, partialArcs, ddashed)
>-    XParms  xp;
>-    Parms   p;
>-    Bool    partialArcs;
>-    Bool    ddashed;
>-{
>-    int     i;
>-    int     rows;       /* Number of rows filled in current column	    */
>-    int     x, y;       /* base of square to draw the circle in		    */
>-    int     xorg, yorg; /* Used to get from column to column or row to row  */
>-    int     size;
>-    int     half;
>-    int     startAngle, arcAngle;
>-
>-    if(ddashed)
>-	pgc = xp->ddfggc;
>-    else
>-	pgc = xp->fggc;
>-
>-    size = p->special;
>-    half = (size + 19) / 20;
>-    arcs = (XArc *)malloc((p->objects) * sizeof(XArc));
>-    x = xorg = half; y = yorg = half;
>-    rows = 0;
>-    startAngle = DegreesToX(0);
>-    arcAngle = DegreesToX(360);
>-
>-    for (i = 0; i != p->objects; i++) {    
>-	arcs[i].x = x;
>-	arcs[i].y = y;
>-	arcs[i].width = size;
>-	arcs[i].height = size;
>-	arcs[i].angle1 = startAngle;
>-	arcs[i].angle2 = arcAngle;
>-
>-	if (partialArcs) {
>-	    startAngle += DegreesToX(30);
>-	    if (startAngle >= DegreesToX(360)) startAngle -= DegreesToX(360);
>-	    arcAngle -= DegreesToX(20);
>-	    if (arcAngle <= DegreesToX(0)) arcAngle += DegreesToX(360);
>-	}
>-
>-	y += size + 1;
>-	rows++;
>-	if (y >= HEIGHT - size  - half || rows == MAXROWS) {
>-	    /* Go to next column */
>-	    rows = 0;
>-	    x += size + 1;
>-	    if (x >= WIDTH - size) {
>-		yorg++;
>-		if (yorg >= size + half || yorg >= HEIGHT - size - half) {
>-		    yorg = half;
>-		    xorg++;
>-		    if (xorg >= size + half || xorg >= WIDTH - size - half) {
>-			xorg = half;
>-		    }
>-		}
>-		x = xorg;
>-	    }
>-	    y = yorg;
>-	}
>-    }
>-}
>-
>-int InitCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateCircles(xp, p, False, False);
>-    return reps;
>-}
>-
>-int InitPartCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateCircles(xp, p, True, False);
>-    return reps;
>-}
>-
>-
>-int InitChordPartCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateCircles(xp, p, True, False);
>-    XSetArcMode(xp->d, xp->bggc, ArcChord);
>-    XSetArcMode(xp->d, xp->fggc, ArcChord);
>-    return reps;
>-}
>-
>-
>-int InitSlicePartCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateCircles(xp, p, True, False);
>-    XSetArcMode(xp->d, xp->bggc, ArcPieSlice);
>-    XSetArcMode(xp->d, xp->fggc, ArcPieSlice);
>-    return reps;
>-}
>-
>-static void
>-GenerateWideCircles (xp, p, partialArcs, ddashed)
>-    XParms  xp;
>-    Parms   p;
>-    Bool    partialArcs;
>-    Bool    ddashed;
>-{
>-    int	    size;
>-
>-    GenerateCircles(xp, p, partialArcs, ddashed);
>-
>-    size = p->special;
>-    if(ddashed) {
>-	XSetLineAttributes(xp->d, xp->ddbggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-	XSetLineAttributes(xp->d, xp->ddfggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-    }
>-    else {
>-	XSetLineAttributes(xp->d, xp->bggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-	XSetLineAttributes(xp->d, xp->fggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-    }
>-}
>-
>-int InitWideCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateWideCircles (xp, p, False, False);
>-    return reps;
>-}
>- 
>-int InitPartWideCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateWideCircles (xp, p, True, False);
>-    return reps;
>-}
>- 
>-int InitDashedCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateCircles(xp, p, False, False);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes(xp->d, xp->bggc, 0, LineOnOffDash, CapButt, JoinMiter);
>-    XSetLineAttributes(xp->d, xp->fggc, 0, LineOnOffDash, CapButt, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->fggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->bggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitWideDashedCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		size;
>-    XGCValues   gcv;
>-    char	dashes[2];
>-
>-    GenerateWideCircles(xp, p, False, False);
>-    size = p->special;
>-    size = (size + 9) / 10;
>-
>-    /* Modify GCs to draw dashed */
>-    dashes[0] = 2*size;   dashes[1] = 2*size;
>-    gcv.line_style = LineOnOffDash;
>-    XChangeGC(xp->d, xp->fggc, GCLineStyle, &gcv);
>-    XChangeGC(xp->d, xp->bggc, GCLineStyle, &gcv);
>-    XSetDashes(xp->d, xp->fggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->bggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitDoubleDashedCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateCircles(xp, p, False, True);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes(xp->d, xp->ddbggc, 0, LineDoubleDash, CapButt, JoinMiter);
>-    XSetLineAttributes(xp->d, xp->ddfggc, 0, LineDoubleDash, CapButt, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->ddfggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->ddbggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitWideDoubleDashedCircles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		size;
>-    XGCValues   gcv;
>-    char	dashes[2];
>-
>-    GenerateWideCircles(xp, p, False, True);
>-    size = p->special;
>-    size = (size + 9) / 10;
>-
>-    /* Modify GCs to draw dashed */
>-    dashes[0] = 2*size;   dashes[1] = 2*size;
>-    gcv.line_style = LineDoubleDash;
>-    XChangeGC(xp->d, xp->ddfggc, GCLineStyle, &gcv);
>-    XChangeGC(xp->d, xp->ddbggc, GCLineStyle, &gcv);
>-    XSetDashes(xp->d, xp->ddfggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->ddbggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-static void GenerateEllipses(xp, p, partialArcs, ddashed)
>-    XParms  xp;
>-    Parms   p;
>-    int    partialArcs;
>-    Bool    ddashed;
>-{
>-    int     size;
>-    int     half;
>-    int     rows;       /* Number of rows filled in current column	    */
>-    int     i;
>-    int     x, y;	    /* base of square to draw ellipse in	    */
>-    int     vsize, vsizeinc;
>-    int     dir;
>-    int     startAngle, arcAngle;
>-
>-    if(ddashed)
>-	pgc = xp->ddfggc;
>-    else
>-	pgc = xp->fggc;
>-
>-    size = p->special;
>-    half = (size + 19) / 20;
>-    arcs = (XArc *)malloc((p->objects) * sizeof(XArc));
>-    vsize = 1;
>-    vsizeinc = (size - 1) / (p->objects - 1);
>-    if (vsizeinc == 0) vsizeinc = 1;
>-
>-    x = half; y = half;
>-    dir = 0;
>-    rows = 0;
>-    startAngle = DegreesToX(0);
>-    arcAngle = DegreesToX(360);
>-
>-    for (i = 0; i != p->objects; i++) {    
>-	arcs[i].x = x;
>-	arcs[i].y = y;
>-	if ((i & 1) ^ dir) {
>-	    /* Make vertical axis longer */
>-	    arcs[i].width = vsize;
>-	    arcs[i].height = size;
>-	} else {
>-	    /* Make horizontal axis longer */
>-	    arcs[i].width = size;
>-	    arcs[i].height = vsize;
>-	}
>-	arcs[i].angle1 = startAngle;
>-	arcs[i].angle2 = arcAngle;
>-
>-	if (partialArcs) {
>-	    startAngle += DegreesToX(30);
>-	    if (startAngle >= DegreesToX(360)) startAngle -= DegreesToX(360);
>-	    arcAngle -= DegreesToX(20);
>-	    if (arcAngle <= DegreesToX(0)) arcAngle += DegreesToX(360);
>-	}
>-
>-	y += size + 1;
>-	rows++;
>-	if (y >= HEIGHT - size - half || rows == MAXROWS) {
>-	    /* Go to next column */
>-	    rows = 0;
>-	    y = half;
>-	    x += size + 1;
>-	    if (x >= WIDTH - size - half) {
>-		x = half;
>-	    }
>-	}
>-	
>-	vsize += vsizeinc;
>-	if (vsize > size) {
>-	    vsize -= size;
>-	    dir = 1 - dir;
>-	}
>-    }
>-}
>-
>-int InitEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateEllipses(xp, p, False, False);
>-    return reps;
>-}
>-
>-
>-int InitPartEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateEllipses(xp, p, True, False);
>-    return reps;
>-}
>-
>-
>-int InitChordPartEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateEllipses(xp, p, True, False);
>-    XSetArcMode(xp->d, xp->bggc, ArcChord);
>-    XSetArcMode(xp->d, xp->fggc, ArcChord);
>-    return reps;
>-}
>-
>-
>-int InitSlicePartEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateEllipses(xp, p, True, False);
>-    XSetArcMode(xp->d, xp->bggc, ArcPieSlice);
>-    XSetArcMode(xp->d, xp->fggc, ArcPieSlice);
>-    return reps;
>-}
>-
>-
>-static void
>-GenerateWideEllipses (xp, p, partialArcs, ddashed)
>-    XParms  xp;
>-    Parms   p;
>-    Bool    partialArcs;
>-    Bool    ddashed;
>-{
>-    int size;
>-
>-    GenerateEllipses (xp, p, partialArcs, ddashed);
>-    size = p->special;
>-    if(ddashed) {
>-	XSetLineAttributes(xp->d, xp->ddbggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-	XSetLineAttributes(xp->d, xp->ddfggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-    }
>-    else {
>-	XSetLineAttributes(xp->d, xp->bggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-	XSetLineAttributes(xp->d, xp->fggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-    }
>-
>-}
>-
>-int InitWideEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateWideEllipses(xp, p, False, False);
>-    return reps;
>-}
>- 
>-int InitPartWideEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateWideEllipses(xp, p, True, False);
>-    return reps;
>-}
>- 
>-int InitDashedEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateEllipses(xp, p, False, False);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes(xp->d, xp->bggc, 0, LineOnOffDash, CapButt, JoinMiter);
>-    XSetLineAttributes(xp->d, xp->fggc, 0, LineOnOffDash, CapButt, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->fggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->bggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitWideDashedEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		size;
>-    XGCValues   gcv;
>-    char	dashes[2];
>-
>-    GenerateWideEllipses(xp, p, False, False);
>-    size = p->special;
>-    size = (size + 9) / 10;
>-
>-    /* Modify GCs to draw dashed */
>-    dashes[0] = 2*size;   dashes[1] = 2*size;
>-    gcv.line_style = LineOnOffDash;
>-    XChangeGC(xp->d, xp->fggc, GCLineStyle, &gcv);
>-    XChangeGC(xp->d, xp->bggc, GCLineStyle, &gcv);
>-    XSetDashes(xp->d, xp->fggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->bggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitDoubleDashedEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateEllipses(xp, p, False, True);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes(xp->d, xp->ddbggc, 0, LineDoubleDash, CapButt, JoinMiter);
>-    XSetLineAttributes(xp->d, xp->ddfggc, 0, LineDoubleDash, CapButt, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->ddfggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->ddbggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitWideDoubleDashedEllipses(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		size;
>-    XGCValues   gcv;
>-    char	dashes[2];
>-
>-    GenerateWideEllipses(xp, p, False, True);
>-    size = p->special;
>-    size = (size + 9) / 10;
>-
>-    /* Modify GCs to draw dashed */
>-    dashes[0] = 2*size;   dashes[1] = 2*size;
>-    gcv.line_style = LineDoubleDash;
>-    XChangeGC(xp->d, xp->ddfggc, GCLineStyle, &gcv);
>-    XChangeGC(xp->d, xp->ddbggc, GCLineStyle, &gcv);
>-    XSetDashes(xp->d, xp->ddfggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->ddbggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-void DoArcs(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != reps; i++) {
>-        XDrawArcs(xp->d, xp->w, pgc, arcs, p->objects);
>-        if (pgc == xp->ddbggc)
>-            pgc = xp->ddfggc;
>-        else if(pgc == xp->ddfggc)
>-            pgc = xp->ddbggc;
>-        else if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void DoFilledArcs(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != reps; i++) {
>-        XFillArcs(xp->d, xp->w, pgc, arcs, p->objects);
>-        if (pgc == xp->ddbggc)
>-            pgc = xp->ddfggc;
>-        else if(pgc == xp->ddfggc)
>-            pgc = xp->ddbggc;
>-        else if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void EndArcs(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    free(arcs);
>-}
>-
>Index: xc/programs/x11perf/do_blt.c
>===================================================================
>RCS file: xc/programs/x11perf/do_blt.c
>diff -N xc/programs/x11perf/do_blt.c
>--- xc/programs/x11perf/do_blt.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,594 +0,0 @@
>-/* $Xorg: do_blt.c,v 1.4 2000/11/30 12:16:31 pookie Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-#include <stdio.h>
>-
>-#define NUMPOINTS 100
>-
>-static Pixmap   pix;
>-static XImage   *image;
>-static XPoint   points[NUMPOINTS];
>-static XSegment *segsa, *segsb;
>-
>-#define NegMod(x, y) ((y) - (((-x)-1) % (7)) - 1)
>-
>-void InitBltLines()
>-{
>-    int i, x, y;
>-
>-    points[0].x = points[0].y = y = 0;
>-    for (i = 1; i != NUMPOINTS/2; i++) {    
>-	if (i & 1) {
>-	    points[i].x = WIDTH-1;
>-	} else {
>-	    points[i].x = 0;
>-	}
>-	y += HEIGHT / (NUMPOINTS/2);
>-	points[i].y = y;
>-    }
>-    
>-    x = 0;
>-    for (i = NUMPOINTS/2; i!= NUMPOINTS; i++) {
>-	if (i & 1) {
>-	    points[i].y = HEIGHT-1;
>-	} else {
>-	    points[i].y = 0;
>-	}
>-	x += WIDTH / (NUMPOINTS/2);
>-	points[i].x = x;
>-    }
>-}
>-
>-int InitScroll(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    InitBltLines();
>-    XDrawLines(xp->d, xp->w, xp->fggc, points, NUMPOINTS, CoordModeOrigin);
>-    return reps;
>-}
>-
>-void DoScroll(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i, size, x, y, xorg, yorg, delta;
>-
>-    size = p->special;
>-    xorg = 0;   yorg = 0;
>-    x    = 0;   y    = 0;
>-    if (xp->version == VERSION1_2) {
>-	delta = 1;
>-    } else {
>-	/* Version 1.2 only scrolled up by 1 scanline, which made hardware
>-	   using page-mode access to VRAM look better on paper than it would
>-	   perform in a more realistic scroll.  So we've changed to scroll by
>-	   the height of the 6x13 fonts. */
>-	delta = 13;
>-    }
>-
>-    for (i = 0; i != reps; i++) {
>-	XCopyArea(xp->d, xp->w, xp->w, xp->fggc, x, y + delta,
>-	    size, size, x, y);
>-	y += size;
>-	if (y + size + delta > HEIGHT) {
>-	    yorg += delta;
>-	    if (yorg >= size || yorg + size + delta > HEIGHT) {
>-		yorg = 0;
>-		xorg++;
>-		if (xorg >= size || xorg + size > WIDTH) {
>-		    xorg = 0;
>-		}
>-	    }
>-	    y = yorg;
>-	    x += size;
>-	    if (x + size > WIDTH) {
>-		x = xorg;
>-	    }
>-	}
>-    }
>-}
>-
>-void MidScroll(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XClearWindow(xp->d, xp->w);
>-    XDrawLines(xp->d, xp->w, xp->fggc, points, NUMPOINTS, CoordModeOrigin);
>-}
>-
>-void EndScroll(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-}
>-
>-static void InitCopyLocations(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int x1, y1, x2, y2, size, i;
>-    int xinc, yinc;
>-    int width, height;
>-
>-    /* Try to exercise all alignments of src and destination equally, as well
>-       as all 4 top-to-bottom/bottom-to-top, left-to-right, right-to-left
>-       copying directions.  Computation done here just to make sure slow
>-       machines aren't measuring anything but the XCopyArea calls.
>-    */
>-    size = p->special;
>-    xinc = (size & ~3) + 1;
>-    yinc = xinc + 3;
>-
>-    width = (WIDTH - size) & ~31;
>-    height = (HEIGHT - size) & ~31;
>-    
>-    x1 = 0;
>-    y1 = 0;
>-    x2 = width;
>-    y2 = height;
>-    
>-    segsa = (XSegment *)malloc(reps * sizeof(XSegment));
>-    segsb = (XSegment *)malloc(reps * sizeof(XSegment));
>-    for (i = 0; i != reps; i++) {
>-	segsa[i].x1 = x1;
>-	segsa[i].y1 = y1;
>-	segsa[i].x2 = x2;
>-	segsa[i].y2 = y2;
>-
>-	/* Move x2, y2, location backward */
>-	x2 -= xinc;
>-	if (x2 < 0) {
>-	    x2 = NegMod(x2, width);
>-	    y2 -= yinc;
>-	    if (y2 < 0) {
>-		y2 = NegMod(y2, height);
>-	    }
>-	}
>-
>-	segsb[i].x1 = x1;
>-	segsb[i].y1 = y1;
>-	segsb[i].x2 = x2;
>-	segsb[i].y2 = y2;
>-
>-	/* Move x1, y1 location forward */
>-	x1 += xinc;
>-	if (x1 > width) {
>-	    x1 %= 32;
>-	    y1 += yinc;
>-	    if (y1 > height) {
>-		y1 %= 32;
>-	    }
>-	}
>-    } /* end for */
>-}
>-
>-
>-int InitCopyWin(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    (void) InitScroll(xp, p, reps);
>-    InitCopyLocations(xp, p, reps);
>-    return reps;
>-}
>-
>-int InitCopyPix(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GC		pixgc;
>-    (void) InitCopyWin(xp, p, reps);
>-
>-    /* Create pixmap to write stuff into, and initialize it */
>-    pix = XCreatePixmap(xp->d, xp->w, WIDTH, HEIGHT, xp->vinfo.depth);
>-    pixgc = XCreateGC(xp->d, pix, 0, 0);
>-    /* need a gc with GXcopy cos pixmaps contain junk on creation. mmm */
>-    XCopyArea(xp->d, xp->w, pix, pixgc, 0, 0, WIDTH, HEIGHT, 0, 0);
>-    XFreeGC(xp->d, pixgc);
>-    return reps;
>-}
>-
>-Bool InitGetImage(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    (void) InitCopyWin(xp, p, reps);
>-
>-    /* Create image to stuff bits into */
>-    image = XGetImage(xp->d, xp->w, 0, 0, WIDTH, HEIGHT, xp->planemask,
>-		      p->font==0?ZPixmap:XYPixmap);
>-    if(image==0){
>-	printf("XGetImage failed\n");
>-	return False;
>-    }	
>-    return reps;
>-}
>-
>-Bool InitPutImage(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    if(!InitGetImage(xp, p, reps))return False;
>-    XClearWindow(xp->d, xp->w);
>-    return reps;
>-}
>-
>-static void CopyArea(xp, p, reps, src, dst)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-    Drawable src, dst;
>-{
>-    int i, size;
>-    XSegment *sa, *sb;
>-
>-    size = p->special;
>-    for (sa = segsa, sb = segsb, i = 0; i != reps; i++, sa++, sb++) {
>-	XCopyArea(xp->d, src, dst, xp->fggc,
>-	    sa->x1, sa->y1, size, size, sa->x2, sa->y2);
>-	XCopyArea(xp->d, src, dst, xp->fggc,
>-	    sa->x2, sa->y2, size, size, sa->x1, sa->y1);
>-	XCopyArea(xp->d, src, dst, xp->fggc,
>-	    sb->x2, sb->y2, size, size, sb->x1, sb->y1);
>-	XCopyArea(xp->d, src, dst, xp->fggc,
>-	    sb->x1, sb->y1, size, size, sb->x2, sb->y2);
>-    }
>-}
>-
>-void DoCopyWinWin(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    CopyArea(xp, p, reps, xp->w, xp->w);
>-}
>-
>-void DoCopyPixWin(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    CopyArea(xp, p, reps, pix, xp->w);
>-}
>-
>-void DoCopyWinPix(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    CopyArea(xp, p, reps, xp->w, pix);
>-    xp->p = pix;	/* HardwareSync will now sync on pixmap */
>-}
>-
>-void DoCopyPixPix(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    CopyArea(xp, p, reps, pix, pix);
>-    xp->p = pix;	/* HardwareSync will now sync on pixmap */
>-}
>-
>-void DoGetImage(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i, size;
>-    XSegment *sa, *sb;
>-    int format;
>-
>-    size = p->special;
>-    format = (p->font == 0) ? ZPixmap : XYPixmap;
>-    for (sa = segsa, sb = segsb, i = 0; i != reps; i++, sa++, sb++) {
>-	XDestroyImage(image);
>-	image = XGetImage(xp->d, xp->w, sa->x1, sa->y1, size, size,
>-	    xp->planemask, format);
>-	if (image) XDestroyImage(image);
>-	image = XGetImage(xp->d, xp->w, sa->x2, sa->y2, size, size,
>-	    xp->planemask, format);
>-	if (image) XDestroyImage(image);
>-	image = XGetImage(xp->d, xp->w, sb->x2, sb->y2, size, size,
>-	    xp->planemask, format);
>-	if (image) XDestroyImage(image);
>-	image = XGetImage(xp->d, xp->w, sb->x1, sb->y1, size, size,
>-	    xp->planemask, format);
>-/*
>-
>-One might expect XGetSubImage to be slightly faster than XGetImage.  Go look
>-at the code in Xlib.  MIT X11R3 ran approximately 30 times slower for a 500x500
>-rectangle.
>-
>-	(void) XGetSubImage(xp->d, xp->w, sa->x1, sa->y1, size, size,
>-	    xp->planemask, ZPixmap, image, sa->x2, sa->y2);
>-	(void) XGetSubImage(xp->d, xp->w, sa->x2, sa->y2, size, size,
>-	    xp->planemask, ZPixmap, image, sa->x1, sa->y1);
>-	(void) XGetSubImage(xp->d, xp->w, sb->x2, sb->y2, size, size,
>-	    xp->planemask, ZPixmap, image, sb->x2, sb->y2);
>-	(void) XGetSubImage(xp->d, xp->w, sb->x1, sb->y1, size, size,
>-	    xp->planemask, ZPixmap, image, sb->x2, sb->y2);
>-*/
>-    }
>-}
>-
>-void DoPutImage(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i, size;
>-    XSegment *sa, *sb;
>-
>-    size = p->special;
>-    for (sa = segsa, sb = segsb, i = 0; i != reps; i++, sa++, sb++) {
>-	XPutImage(xp->d, xp->w, xp->fggc, image,
>-	    sa->x1, sa->y1, sa->x2, sa->y2, size, size);
>-	XPutImage(xp->d, xp->w, xp->fggc, image,
>-	    sa->x2, sa->y2, sa->x1, sa->y1, size, size);
>-	XPutImage(xp->d, xp->w, xp->fggc, image,
>-	    sb->x2, sb->y2, sb->x2, sb->y2, size, size);
>-	XPutImage(xp->d, xp->w, xp->fggc, image,
>-	    sb->x1, sb->y1, sb->x2, sb->y2, size, size);
>-    }
>-}
>-
>-#ifdef MITSHM
>-
>-#include <sys/types.h>
>-#include <sys/ipc.h>
>-#include <sys/shm.h>
>-#include <X11/extensions/XShm.h>
>-
>-static XImage		shm_image;
>-static XShmSegmentInfo	shm_info;
>-
>-static int haderror;
>-static int (*origerrorhandler)();
>-shmerrorhandler(d,e)
>-Display *d;
>-XErrorEvent *e;
>-{
>-    haderror++;
>-    if(e->error_code==BadAccess)fprintf(stderr,"failed to attach shared memory\n");
>-    else (*origerrorhandler)(d,e);
>-}
>-int InitShmPutImage (xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int	image_size;
>-
>-    if(!InitGetImage(xp, p, reps))return False;
>-    if (!XShmQueryExtension(xp->d)) {
>-	/*
>-	 * Clean up here because cleanup function is not called if this
>-	 * function fails
>-	 */
>-	if (image)
>-	    XDestroyImage(image);
>-	image = NULL;
>-	free(segsa);
>-	free(segsb);
>-	return False;
>-    }
>-    XClearWindow(xp->d, xp->w);
>-    shm_image = *image;
>-    image_size = image->bytes_per_line * image->height;
>-    /* allow XYPixmap choice: */
>-    if(p->font)image_size *= xp->vinfo.depth;
>-    shm_info.shmid = shmget(IPC_PRIVATE, image_size, IPC_CREAT|0777);
>-    if (shm_info.shmid < 0)
>-    {
>-	/*
>-	 * Clean up here because cleanup function is not called if this
>-	 * function fails
>-	 */
>-	if (image)
>-	    XDestroyImage(image);
>-	image = NULL;
>-	free(segsa);
>-	free(segsb);
>-	perror ("shmget");
>-	return False;
>-    }
>-    shm_info.shmaddr = (char *) shmat(shm_info.shmid, 0, 0);
>-    if (shm_info.shmaddr == ((char *) -1))
>-    {
>-	/*
>-	 * Clean up here because cleanup function is not called if this
>-	 * function fails
>-	 */
>-	if (image)
>-	    XDestroyImage(image);
>-	image = NULL;
>-	free(segsa);
>-	free(segsb);
>-	perror ("shmat");
>-	shmctl (shm_info.shmid, IPC_RMID, 0);
>-	return False;
>-    }
>-    shm_info.readOnly = True;
>-    XSync(xp->d,True);
>-    haderror = False;
>-    origerrorhandler = XSetErrorHandler(shmerrorhandler);
>-    XShmAttach (xp->d, &shm_info);
>-    XSync(xp->d,True);	/* wait for error or ok */
>-    XSetErrorHandler(origerrorhandler);
>-    if(haderror){
>-	/*
>-	 * Clean up here because cleanup function is not called if this
>-	 * function fails
>-	 */
>-	if (image)
>-	    XDestroyImage(image);
>-	image = NULL;
>-	free(segsa);
>-	free(segsb);
>-	if(shmdt (shm_info.shmaddr)==-1)
>-	    perror("shmdt:");
>-	if(shmctl (shm_info.shmid, IPC_RMID, 0)==-1)
>-	    perror("shmctl rmid:");
>-	return False;
>-    }
>-    shm_image.data = shm_info.shmaddr;
>-    memmove( shm_image.data, image->data, image_size);
>-    shm_image.obdata = (char *) &shm_info;
>-    return reps;
>-}
>-
>-void DoShmPutImage(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i, size;
>-    XSegment *sa, *sb;
>-
>-    size = p->special;
>-    for (sa = segsa, sb = segsb, i = 0; i != reps; i++, sa++, sb++) {
>-	XShmPutImage(xp->d, xp->w, xp->fggc, &shm_image,
>-	    sa->x1, sa->y1, sa->x2, sa->y2, size, size, False);
>-	XShmPutImage(xp->d, xp->w, xp->fggc, &shm_image,
>-	    sa->x2, sa->y2, sa->x1, sa->y1, size, size, False);
>-	XShmPutImage(xp->d, xp->w, xp->fggc, &shm_image,
>-	    sb->x2, sb->y2, sb->x2, sb->y2, size, size, False);
>-	XShmPutImage(xp->d, xp->w, xp->fggc, &shm_image,
>-	    sb->x1, sb->y1, sb->x2, sb->y2, size, size, False);
>-    }
>-}
>-
>-void EndShmPutImage(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    void    EndGetImage();
>-
>-    EndGetImage (xp, p);
>-    XShmDetach (xp->d, &shm_info);
>-    XSync(xp->d, False);	/* need server to detach so can remove id */
>-    if(shmdt (shm_info.shmaddr)==-1)
>-	perror("shmdt:");
>-    if(shmctl (shm_info.shmid, IPC_RMID, 0)==-1)
>-	perror("shmctl rmid:");
>-}
>-
>-#endif
>-
>-
>-void MidCopyPix(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XClearWindow(xp->d, xp->w);
>-}
>-
>-void EndCopyWin(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    EndScroll(xp, p);
>-    free(segsa);
>-    free(segsb);
>-}
>-
>-void EndCopyPix(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    EndCopyWin(xp, p);
>-    XFreePixmap(xp->d, pix);
>-    /*
>-     * Ensure that the next test doesn't try and sync on the pixmap
>-     */
>-    xp->p = (Pixmap)0;
>-}
>-
>-void EndGetImage(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    EndCopyWin(xp, p);
>-    if (image) XDestroyImage(image);
>-}
>-
>-Bool InitCopyPlane(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    XGCValues   gcv;
>-    GC		pixgc;
>-
>-    InitBltLines();
>-    InitCopyLocations(xp, p, reps);
>-
>-    /* Create pixmap to write stuff into, and initialize it */
>-    pix = XCreatePixmap(xp->d, xp->w, WIDTH, HEIGHT, 
>-	    p->font==0 ? 1 : xp->vinfo.depth);
>-    gcv.graphics_exposures = False;
>-    gcv.foreground = 0;
>-    gcv.background = 1;
>-    pixgc = XCreateGC(xp->d, pix, 
>-		GCForeground | GCBackground | GCGraphicsExposures, &gcv);
>-    XFillRectangle(xp->d, pix, pixgc, 0, 0, WIDTH, HEIGHT);
>-    gcv.foreground = 1;
>-    gcv.background = 0;
>-    XChangeGC(xp->d, pixgc, GCForeground | GCBackground, &gcv);
>-    XDrawLines(xp->d, pix, pixgc, points, NUMPOINTS, CoordModeOrigin);
>-    XFreeGC(xp->d, pixgc);
>-
>-    return reps;
>-}
>-
>-void DoCopyPlane(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		i, size;
>-    XSegment    *sa, *sb;
>-
>-    size = p->special;
>-    for (sa = segsa, sb = segsb, i = 0; i != reps; i++, sa++, sb++) {
>-	XCopyPlane(xp->d, pix, xp->w, xp->fggc,
>-	    sa->x1, sa->y1, size, size, sa->x2, sa->y2, 1);
>-	XCopyPlane(xp->d, pix, xp->w, xp->fggc,
>-	    sa->x2, sa->y2, size, size, sa->x1, sa->y1, 1);
>-	XCopyPlane(xp->d, pix, xp->w, xp->fggc,
>-	    sb->x2, sb->y2, size, size, sb->x1, sb->y1, 1);
>-	XCopyPlane(xp->d, pix, xp->w, xp->fggc,
>-	    sb->x1, sb->y1, size, size, sb->x2, sb->y2, 1);
>-    }
>-}
>-
>Index: xc/programs/x11perf/do_complex.c
>===================================================================
>RCS file: xc/programs/x11perf/do_complex.c
>diff -N xc/programs/x11perf/do_complex.c
>--- xc/programs/x11perf/do_complex.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,201 +0,0 @@
>-/* $Xorg: do_complex.c,v 1.3 2000/08/17 19:54:09 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-#define NUM_POINTS 4    /* 4 points to an arrowhead */
>-#define NUM_ANGLES 3    /* But mostly it looks like a triangle */
>-static XPoint   *points;
>-static GC       pgc;
>-
>-extern double sin();
>-extern double cos();
>-extern double tan();
>-extern double sqrt();
>-#define PI  3.14159265357989
>-
>-int InitComplexPoly(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j, numPoints;
>-    int     x, y;
>-    int     size, iradius;
>-    double  phi, phiinc, radius, delta, phi2;
>-    XPoint  *curPoint;
>-
>-    pgc = xp->fggc;
>-
>-    size = p->special;
>-    phi = 0.0;
>-    delta = 2.0 * PI / ((double) NUM_ANGLES);
>-    if (xp->version == VERSION1_2) {
>-	radius = ((double) size) * sqrt(3.0)/2.0;
>-	phiinc = delta/10.0;
>-    } else {
>-	/* Version 1.2's radius computation was completely bogus, and resulted
>-	   in triangles with sides about 50% longer than advertised.  Since
>-	   in version 1.3 triangles are scaled to cover size^2 pixels, we do
>-	   the same computation here.  The arrowheads are a little larger than
>-	   simple triangles, because they lose 1/3 of their area due to the
>-	   notch cut out from them, so radius has to be sqrt(3/2) larger than
>-	   for simple triangles.
>-	 */
>-	radius = ((double) size) * sqrt(sqrt(4.0/3.0));
>-	phiinc = 1.75*PI / ((double) p->objects);
>-    }
>-    iradius = (int) radius + 1;
>-
>-    numPoints = (p->objects) * NUM_POINTS;  
>-    points = (XPoint *)malloc(numPoints * sizeof(XPoint));
>-    curPoint = points;
>-    x = iradius;
>-    y = iradius;
>-    for (i = 0; i != p->objects; i++) {
>-	for (j = 0; j != NUM_ANGLES; j++) {
>-	    phi2 = phi + ((double) j) * delta;
>-	    curPoint->x = (int) ((double)x + (radius * cos(phi2)) + 0.5);
>-	    curPoint->y = (int) ((double)y + (radius * sin(phi2)) + 0.5);
>-	    curPoint++;
>-	}
>-	curPoint->x = x;
>-	curPoint->y = y;
>-	curPoint++;
>-
>-	phi += phiinc;
>-	y += 2 * iradius;
>-	if (y + iradius >= HEIGHT) {
>-	    y = iradius;
>-	    x += 2 * iradius;
>-	    if (x + iradius >= WIDTH) {
>-		x = iradius;
>-	    }
>-	}
>-    }
>-    return reps;
>-}
>-
>-void DoComplexPoly(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j;
>-    XPoint  *curPoint;
>-
>-    for (i = 0; i != reps; i++) {
>-        curPoint = points;
>-        for (j = 0; j != p->objects; j++) {
>-            XFillPolygon(xp->d, xp->w, pgc, curPoint, NUM_POINTS, Complex, 
>-			 CoordModeOrigin);
>-            curPoint += NUM_POINTS;
>-	  }
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void EndComplexPoly(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    free(points);
>-}
>-
>-int InitGeneralPoly (xp,p,reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j, numPoints;
>-    int	    nsides;
>-    int	    x, y;
>-    int     size, iradius;
>-    double  phi, phiinc, inner_radius, outer_radius, delta, phi2;
>-    XPoint  *curPoint;
>-
>-    pgc = xp->fggc;
>-    size = p->special;
>-    nsides = (int) p->font;
>-    phi = 0.0;
>-    delta = 2.0 * PI / ((double) nsides);
>-    phiinc = delta / 10.0;
>-
>-    inner_radius = size / sqrt (nsides * tan (PI / nsides));
>-    outer_radius = inner_radius / cos (PI / (2 * nsides));
>-    numPoints = p->objects * nsides;
>-    points = (XPoint *) malloc (numPoints * sizeof (XPoint));
>-    curPoint = points;
>-    iradius = outer_radius + 1;
>-    x = iradius;
>-    y = iradius;
>-    for (i = 0; i < p->objects; i++) {
>-	phi2 = phi;
>-	for (j = 0; j < nsides; j++) {
>-	    curPoint->x = x + (outer_radius * cos(phi2) + 0.5);
>-	    curPoint->y = y + (outer_radius * sin(phi2) + 0.5);
>-	    curPoint++;
>-	    phi2 += delta;
>-	}
>-	phi += phiinc;
>-	y += 2 * iradius;
>-	if (y + iradius >= HEIGHT) {
>-	    y = iradius;
>-	    x += 2 * iradius;
>-	    if (x + iradius >= WIDTH) {
>-		x = iradius;
>-	    }
>-	}
>-    }
>-    return reps;
>-}
>-
>-void DoGeneralPoly(xp,p,reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j;
>-    int	    nsides;
>-    int	    mode;
>-    XPoint  *curPoint;
>-
>-    nsides = (int) p->font;
>-    mode = (int) p->bfont;
>-    for (i = 0; i != reps; i++) {
>-        curPoint = points;
>-        for (j = 0; j != p->objects; j++) {
>-            XFillPolygon(xp->d, xp->w, pgc, curPoint, nsides, mode, 
>-			 CoordModeOrigin);
>-            curPoint += nsides;
>-	  }
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>Index: xc/programs/x11perf/do_dots.c
>===================================================================
>RCS file: xc/programs/x11perf/do_dots.c
>diff -N xc/programs/x11perf/do_dots.c
>--- xc/programs/x11perf/do_dots.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,70 +0,0 @@
>-/* $Xorg: do_dots.c,v 1.3 2000/08/17 19:54:09 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-static XPoint   *points;
>-static GC       pgc;
>-
>-int InitDots(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    pgc = xp->fggc;
>-
>-    points = (XPoint *)malloc(p->objects * sizeof(XPoint));
>-
>-    for (i = 0; i != p->objects; i++) {
>-	points[i].x = 2 * (i/MAXROWS);
>-	points[i].y = 2 * (i%MAXROWS);
>-    }
>-    return reps;
>-}
>-
>-void DoDots(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i;
>-
>-    for (i = 0; i != reps; i++) {
>-        XDrawPoints(xp->d, xp->w, pgc, points, p->objects, CoordModeOrigin);
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void EndDots(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    free(points);
>-}
>-
>Index: xc/programs/x11perf/do_lines.c
>===================================================================
>RCS file: xc/programs/x11perf/do_lines.c
>diff -N xc/programs/x11perf/do_lines.c
>--- xc/programs/x11perf/do_lines.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,320 +0,0 @@
>-/* $Xorg: do_lines.c,v 1.3 2000/08/17 19:54:09 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-static XPoint   *points;
>-static GC       pgc;
>-
>-static void GenerateLines(xp, p, ddashed)
>-    XParms  xp;
>-    Parms   p;
>-    Bool    ddashed;
>-{
>-    int size;
>-    int half;		/* Half of width if wide line		        */
>-    int i;
>-    int     rows;       /* Number of rows filled in current column      */
>-    int x, y;		/* Next point					*/
>-    int xdir, ydir;	/* Which direction x, y are going		*/
>-    int bigxdir;	
>-    int x1, y1;		/* offsets to compute next point from current	*/
>-    int phase;		/* how far into 0..4*(size_1) we are		*/
>-    float phasef;       /* how far we are in real numbers		*/
>-    float phaseinc;     /* how much to increment phasef at each segment */
>-    int size4;		/* 4 * size					*/
>-
>-    if(ddashed)
>-	pgc = xp->ddfggc;
>-    else
>-	pgc = xp->fggc;
>-
>-    size = p->special;
>-    size4 = 4 * (size+1);
>-    half = (size + 19) / 20;
>-
>-    points = (XPoint *)malloc((p->objects+1) * sizeof(XPoint));
>-
>-    /* All this x, x1, x1inc, etc. stuff is to create a pattern that
>-	(1) scans down the screen vertically
>-
>-	(2) rotates the endpoints through all possible orientations
>-
>-	(3) bounces off bottom and top of window as needed
>-
>-	(4) moves left or right at each bounce to make things less boring
>-    */
>-
>-    x     = half;
>-    y     = half;
>-    xdir  = 1;
>-    ydir  = 1;
>-    bigxdir = 1;
>-    phasef = 0.0;
>-    phaseinc = ((float)size4) / ((float)p->objects);
>-    if (phaseinc < 1.0) phaseinc = 1.0;
>-    rows = 0;
>-
>-    points[0].x = x;
>-    points[0].y = y;
>-
>-    for (i = 1; i != (p->objects+1); i++) {    
>-	phase = phasef;
>-	switch (phase / (size+1)) {
>-	case 0:
>-	    x1 = size;			
>-	    y1 = phase;
>-	    break;
>-
>-	case 1:
>-	    x1 = size - phase % (size+1);
>-	    y1 = size;
>-	    break;
>-
>-	case 2:
>-	    x1 = phase % (size+1);
>-	    y1 = size;
>-	    break;
>-
>-	case 3:
>-	    x1 = size;
>-	    y1 = size - phase % (size+1);
>-	    break;
>-	} /* end switch */
>-
>-	/* Move down or up the screen */
>-	y += (ydir * y1);
>-
>-	/* If off either top or bottom, backtrack to previous position and go
>-	   the other way instead.  Also move in bigxdir if not already. */
>-	rows++;
>-	if (y < half || y >= (HEIGHT-half) || rows > MAXROWS) {
>-	    rows = 0;
>-	    if (bigxdir > 0) {
>-		if (x + size < WIDTH - half) {
>-		    xdir = 1;
>-		} else {
>-		    bigxdir = -1;
>-		}
>-	    } else {
>-		if (x - size > half) {
>-		    xdir = -1;
>-		} else {
>-		    bigxdir = 1;
>-		}
>-	    }
>-	    ydir = -ydir;
>-	    y += (2 * ydir * y1);
>-	    /* If still off top or bottom, we can't do the line we want.
>-	       This will happen infrequently if the window is not twice the
>-	       length of the line.  So instead, let's draw a line that puts
>-	       the line after this approximately through the center of the
>-	       window.   Since it is very unlikely that both x and y will
>-	       need such adjustment, line length (in pixels) should not
>-	       change...we just can't get the slope we want for this line. */
>-	    if (y < half) {
>-		y = (HEIGHT - y1)/2;
>-		ydir = 1;
>-	    } else if (y > (HEIGHT - half)) {
>-		y = (HEIGHT + y1)/2;
>-		ydir = -1;
>-	    }
>-	}
>-
>-	/* Move x left or right by x1 */
>-	x += (xdir * x1);
>-	xdir = -xdir;
>-	/* Again, if we are off the bottom then we can't really draw the line
>-	   we want.  */
>-	if (x < half) {
>-	    x = (WIDTH - x1)/2;
>-	    xdir = 1;
>-	} else if (x > (WIDTH - half)) {
>-	    x = (WIDTH + x1)/2;
>-	    xdir = -1;
>-	}
>-	points[i].x = x;
>-	points[i].y = y;
>-
>-	/* Increment phasef */
>-	phasef += phaseinc;
>-	if (phasef >= size4) phasef -= size4;
>-
>-    }
>-}
>- 
>-int InitLines(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateLines(xp, p, False);
>-	return reps;
>-}
>-
>-static int GenerateWideLines(xp, p, reps, ddashed)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-    Bool    ddashed;
>-{
>-    int size;
>-
>-    GenerateLines(xp, p, ddashed);
>-
>-    size = p->special;
>-    if(ddashed) {
>-	XSetLineAttributes(xp->d, xp->ddbggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-	XSetLineAttributes(xp->d, xp->ddfggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-    }
>-    else {
>-	XSetLineAttributes(xp->d, xp->bggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-	XSetLineAttributes(xp->d, xp->fggc, (int) ((size + 9) / 10),
>-	    LineSolid, CapRound, JoinRound);
>-    }
>-
>-    return reps;
>-}
>-
>-int InitWideLines(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    return GenerateWideLines(xp, p, reps, False);
>-}
>- 
>-int InitDashedLines(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateLines(xp, p, False);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes(xp->d, xp->bggc, 0, LineOnOffDash, CapButt, JoinMiter);
>-    XSetLineAttributes(xp->d, xp->fggc, 0, LineOnOffDash, CapButt, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->fggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->bggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitWideDashedLines(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		size;
>-    XGCValues   gcv;
>-    char	dashes[2];
>-
>-    (void)GenerateWideLines(xp, p, reps, False);
>-    size = p->special;
>-    size = (size + 9) / 10;
>-
>-    /* Modify GCs to draw dashed */
>-    dashes[0] = 2*size;   dashes[1] = 2*size;
>-    gcv.line_style = LineOnOffDash;
>-    XChangeGC(xp->d, xp->fggc, GCLineStyle, &gcv);
>-    XChangeGC(xp->d, xp->bggc, GCLineStyle, &gcv);
>-    XSetDashes(xp->d, xp->fggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->bggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitDoubleDashedLines(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateLines(xp, p, True);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes(xp->d, xp->ddbggc, 0, LineDoubleDash, CapButt, JoinMiter);
>-    XSetLineAttributes(xp->d, xp->ddfggc, 0, LineDoubleDash, CapButt, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->ddfggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->ddbggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitWideDoubleDashedLines(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		size;
>-    XGCValues   gcv;
>-    char	dashes[2];
>-
>-    (void)GenerateWideLines(xp, p, reps, True);
>-    size = p->special;
>-    size = (size + 9) / 10;
>-
>-    /* Modify GCs to draw dashed */
>-    dashes[0] = 2*size;   dashes[1] = 2*size;
>-    gcv.line_style = LineDoubleDash;
>-    XChangeGC(xp->d, xp->ddfggc, GCLineStyle, &gcv);
>-    XChangeGC(xp->d, xp->ddbggc, GCLineStyle, &gcv);
>-    XSetDashes(xp->d, xp->ddfggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->ddbggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-void DoLines(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != reps; i++)
>-    {
>-        XDrawLines(xp->d, xp->w, pgc, points, p->objects+1, CoordModeOrigin);
>-        if (pgc == xp->ddbggc)
>-            pgc = xp->ddfggc;
>-        else if(pgc == xp->ddfggc)
>-            pgc = xp->ddbggc;
>-        else if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void EndLines(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    free(points);
>-}
>-
>Index: xc/programs/x11perf/do_movewin.c
>===================================================================
>RCS file: xc/programs/x11perf/do_movewin.c
>diff -N xc/programs/x11perf/do_movewin.c
>--- xc/programs/x11perf/do_movewin.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,219 +0,0 @@
>-/* $Xorg: do_movewin.c,v 1.5 2000/11/30 12:19:00 pookie Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-static Window *children;
>-static XPoint *positions;
>-static Window cover;
>-static int rows;
>-static x_offset, y_offset;  /* Private global data for DoMoveWindows */
>-static int xmax, ymax;
>-static delta1;		    /* Private global data for DoResizeWindows */
>-
>-#define STACK (4*(HEIGHT-10)/CHILDSIZE)
>-
>-int InitMoveWindows(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i = 0;
>-
>-    rows = (p->objects + MAXCOLS - 1) / MAXCOLS;
>-    
>-    x_offset = 0;
>-    y_offset = 0;
>-    delta1   = 1;
>-
>-    children = (Window *) malloc (p->objects*sizeof (Window));
>-    positions = (XPoint *) malloc(p->objects*sizeof(XPoint));
>-
>-    xmax = (CHILDSIZE+CHILDSPACE) * (rows > 1 ? MAXCOLS : p->objects);
>-    ymax = rows * (CHILDSIZE+CHILDSPACE);
>-
>-    for (i = 0; i != p->objects; i++) {
>-	positions[i].x = (CHILDSIZE+CHILDSPACE) * (i/rows) + CHILDSPACE/2;
>-	positions[i].y = (CHILDSIZE+CHILDSPACE) * (i%rows) + CHILDSPACE/2;
>-	children[i] = XCreateSimpleWindow(xp->d, xp->w,
>-	    positions[i].x, positions[i].y,
>-	    CHILDSIZE, CHILDSIZE, 0, xp->foreground, xp->foreground);
>-    }
>-    if (p->special)
>-	XMapSubwindows (xp->d, xp->w);
>-    return reps;
>-}
>-
>-void DoMoveWindows(xp, p, reps)
>-    XParms  xp;
>-    Parms p;
>-    int     reps;
>-{
>-    int     i, j;
>-
>-    for (i = 0; i != reps; i++) {
>-	x_offset += 1;
>-	y_offset += 3;
>-	if (y_offset + ymax > HEIGHT)
>-	    y_offset = 0;
>-	if (x_offset + xmax > WIDTH)
>-	    x_offset = 0;
>-	for (j = 0; j != p->objects; j++) {
>-	    XMoveWindow(xp->d, children[j],
>-	    positions[j].x + x_offset, positions[j].y + y_offset);
>-	}
>-    }
>-}
>-
>-void EndMoveWindows(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XDestroySubwindows(xp->d, xp->w);
>-    free(children);
>-    free(positions);
>-}
>-
>-void DoResizeWindows(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j, delta2;
>-
>-    for (i = 0; i != reps; i++) {
>-	delta1 = -delta1;
>-	delta2 = delta1;
>-	for (j = 0; j != p->objects; j++) {
>-	    delta2 = -delta2;
>-	    XResizeWindow(xp->d, children[j],
>-		CHILDSIZE+delta2, CHILDSIZE-delta2);
>-	}
>-    }
>-}
>-
>-int InitCircWindows(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i;
>-    int     pos;
>-    int     color;
>-
>-    children = (Window *) malloc (p->objects * sizeof (Window));
>-    for (i = 0; i != p->objects; i++) {
>-	pos = i % STACK;
>-	color = (i & 1 ? xp->foreground : xp->background);
>-	children[i] = XCreateSimpleWindow (xp->d, xp->w, 
>-	    pos*CHILDSIZE/4 + (i/STACK)*2*CHILDSIZE, pos*CHILDSIZE/4,
>-	    CHILDSIZE, CHILDSIZE, 0, color, color);
>-    }
>-    if (p->special)
>-	XMapSubwindows (xp->d, xp->w);
>-    return reps;
>-}
>-
>-void DoCircWindows(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j;
>-
>-    for (i = 0; i != reps; i++)
>-	for (j = 0; j != p->objects; j++)
>-	    XCirculateSubwindows (xp->d, xp->w, RaiseLowest);
>-}
>-
>-void EndCircWindows(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XDestroySubwindows(xp->d, xp->w);
>-    free(children);
>-}
>-
>-
>-int InitMoveTree(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i = 0;
>-
>-    rows = (p->objects + MAXCOLS - 1) / MAXCOLS;
>-    
>-    x_offset = 0;
>-    y_offset = 0;
>-    delta1   = 1;
>-
>-    children = (Window *) malloc (p->objects*sizeof (Window));
>-    positions = (XPoint *) malloc(p->objects*sizeof(XPoint));
>-
>-    xmax = (CHILDSIZE+CHILDSPACE) * (rows > 1 ? MAXCOLS : p->objects);
>-    ymax = rows * (CHILDSIZE+CHILDSPACE);
>-
>-    cover = XCreateSimpleWindow(xp->d, xp->w,
>-				0, 0, xmax, ymax, 0,
>-				xp->background, xp->background);
>-				
>-    for (i = 0; i != p->objects; i++) {
>-	positions[i].x = (CHILDSIZE+CHILDSPACE) * (i/rows) + CHILDSPACE/2;
>-	positions[i].y = (CHILDSIZE+CHILDSPACE) * (i%rows) + CHILDSPACE/2;
>-	children[i] = XCreateSimpleWindow(xp->d, cover,
>-	    positions[i].x, positions[i].y,
>-	    CHILDSIZE, CHILDSIZE, 0, xp->foreground, xp->foreground);
>-    }
>-    XMapSubwindows (xp->d, cover);
>-    XMapWindow (xp->d, cover);
>-    return reps;
>-}
>-
>-void DoMoveTree(xp, p, reps)
>-    XParms  xp;
>-    Parms p;
>-    int     reps;
>-{
>-    int     i;
>-
>-    for (i = 0; i != reps; i++) {
>-	x_offset += 1;
>-	y_offset += 3;
>-	if (y_offset + ymax > HEIGHT)
>-	    y_offset = 0;
>-	if (x_offset + xmax > WIDTH)
>-	    x_offset = 0;
>-	XMoveWindow(xp->d, cover, x_offset, y_offset);
>-    }
>-}
>-
>-void EndMoveTree(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XDestroyWindow(xp->d, cover);
>-    free(children);
>-    free(positions);
>-}
>Index: xc/programs/x11perf/do_rects.c
>===================================================================
>RCS file: xc/programs/x11perf/do_rects.c
>diff -N xc/programs/x11perf/do_rects.c
>--- xc/programs/x11perf/do_rects.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,127 +0,0 @@
>-/* $Xorg: do_rects.c,v 1.4 2000/08/17 19:54:09 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-#include "bitmaps.h"
>-
>-static XRectangle   *rects;
>-static GC	    pgc;
>-
>-int InitRectangles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-    int size = p->special;
>-    int step;
>-    int x, y;
>-    int rows;
>-    int	lw = 0;
>-
>-    pgc = xp->fggc;
>-
>-    if (p->bfont)
>-    {
>-	lw = atoi (p->bfont);
>-
>-	XSetLineAttributes(xp->d, xp->bggc, lw, LineSolid, CapButt, JoinMiter);
>-	XSetLineAttributes(xp->d, xp->fggc, lw, LineSolid, CapButt, JoinMiter);
>-	lw = (lw >> 1) + 1;
>-    }
>-
>-    rects = (XRectangle *)malloc(p->objects * sizeof(XRectangle));
>-    x = lw;
>-    y = lw;
>-    rows = 0;
>-    if (xp->pack) {
>-	/* Pack rectangles as close as possible, mainly for debugging faster
>-	   tiling, stippling routines in a server */
>-	step = size;
>-    } else {
>-	/* Try to exercise all alignments...any odd number is okay */
>-	step = size + 1 + (size % 2);
>-    }
>-
>-    for (i = 0; i != p->objects; i++) {
>-	rects[i].x = x;
>-        rects[i].y = y;
>-	rects[i].width = rects[i].height = size;
>-
>-	y += step;
>-	rows++;
>-	if (y + size > HEIGHT || rows == MAXROWS) {
>-	    rows = 0;
>-	    y = lw;
>-	    x += step;
>-	    if (x + size > WIDTH) {
>-		x = lw;
>-	    }
>-	}
>-    }
>-
>-    SetFillStyle(xp, p);
>-
>-    return reps;
>-}
>-
>-void DoRectangles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != reps; i++) {
>-        XFillRectangles(xp->d, xp->w, pgc, rects, p->objects);
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void DoOutlineRectangles (xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int	    reps;
>-{
>-    int	i;
>-
>-    for (i = 0; i != reps; i++) {
>-	XDrawRectangles (xp->d, xp->w, pgc, rects, p->objects);
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void EndRectangles(xp, p)
>-    XParms  xp;
>-    Parms p;
>-{
>-    free(rects);
>-}
>-
>Index: xc/programs/x11perf/do_segs.c
>===================================================================
>RCS file: xc/programs/x11perf/do_segs.c
>diff -N xc/programs/x11perf/do_segs.c
>--- xc/programs/x11perf/do_segs.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,402 +0,0 @@
>-/* $Xorg: do_segs.c,v 1.3 2000/08/17 19:54:09 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-static XSegment *segments;
>-static GC       pgc;
>-
>-static void GenerateSegments(xp, p, ddashed)
>-    XParms  xp;
>-    Parms   p;
>-    Bool     ddashed;
>-{
>-    int     size;
>-    int     half;
>-    int     i;
>-    int     rows;	    /* Number of rows filled in current column      */
>-    int     x, y;	    /* base of square to draw in		    */
>-    int     x1, y1, x2, y2; /* offsets into square			    */
>-    int     phase;	    /* how far into 0..8*size we are		    */
>-    int     phaseinc;       /* how much to increment phase at each segment  */
>-    int     size8;	    /* 8 * size					    */
>-    XGCValues   gcv;
>-
>-    if(ddashed)
>-	pgc = xp->ddfggc;
>-    else
>-	pgc = xp->fggc;
>-
>-
>-    size = p->special;
>-    size8 = 8 * size;
>-    half = (size + 19) / 20;
>-
>-    segments = (XSegment *)malloc((p->objects) * sizeof(XSegment));
>-
>-    /* All this x, x1, etc. stuff is to create a pattern that
>-	(1) scans down the screen vertically, with each new segment going
>-	    into a square of size^2.
>-
>-	(2) rotates the endpoints clockwise around the square
>-
>-	(3) rotates by ``large'' steps if we aren't going to paint enough
>-	    segments to get full coverage
>-
>-	(4) uses CapNotLast so we can create segments of length 1 that
>-	    nonetheless have a distinct direction
>-    */
>-
>-    x     = half;  y     = half;
>-    phase = 0;
>-    phaseinc = size8 / p->objects;
>-    if (phaseinc == 0) phaseinc = 1;
>-    rows = 0;
>-
>-    for (i = 0; i != p->objects; i++) {    
>-	switch (phase / size) {
>-	case 0:
>-	    x1 = 0;
>-	    y1 = 0;
>-	    x2 = size;
>-	    y2 = phase;
>-	    break;
>-
>-	case 1:
>-	    x1 = phase % size;    
>-	    y1 = 0;
>-	    x2 = size;
>-	    y2 = size;
>-	    break;
>-
>-	case 2:
>-	    x1 = size;
>-	    y1 = 0;
>-	    x2 = size - phase % size;
>-	    y2 = size;
>-	    break;
>-
>-	case 3:
>-	    x1 = size;
>-	    y1 = phase % size;
>-	    x2 = 0;
>-	    y2 = size;
>-	    break;
>-
>-	case 4:
>-	    x1 = size;
>-	    y1 = size;
>-	    x2 = 0;
>-	    y2 = size - phase % size;
>-	    break;
>-
>-	case 5:
>-	    x1 = size - phase % size;
>-	    y1 = size;
>-	    x2 = 0;
>-	    y2 = 0;
>-	    break;
>-
>-	case 6:
>-	    x1 = 0;
>-	    y1 = size;
>-	    x2 = phase % size;
>-	    y2 = 0;
>-	    break;
>-
>-	case 7:
>-	    x1 = 0;
>-	    y1 = size - phase % size;
>-	    x2 = size;
>-	    y2 = 0;
>-	    break;
>-	} /* end switch */
>-
>-	segments[i].x1 = x + x1;
>-	segments[i].y1 = y + y1;
>-	segments[i].x2 = x + x2;
>-	segments[i].y2 = y + y2;
>-
>-	/* Change square to draw segment in */
>-	rows++;
>-	y += size;
>-	if (y >= HEIGHT - size - half || rows == MAXROWS) {
>-	    /* Go to next column */
>-	    rows = 0;
>-	    y = half;
>-	    x += size;
>-	    if (x >= WIDTH - size - half) {
>-		x = half;
>-	    }
>-	}
>-
>-	/* Increment phase */
>-	phase += phaseinc;
>-	if (phase >= size8) phase -= size8;
>-
>-    }
>-
>-    gcv.cap_style = CapNotLast;
>-
>-    if(ddashed) {
>-	XChangeGC(xp->d, xp->ddfggc, GCCapStyle, &gcv);
>-	XChangeGC(xp->d, xp->ddbggc, GCCapStyle, &gcv);
>-    } else {
>-	XChangeGC(xp->d, xp->fggc, GCCapStyle, &gcv);
>-	XChangeGC(xp->d, xp->bggc, GCCapStyle, &gcv);
>-    }
>-}
>-   
>-int InitSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    GenerateSegments(xp, p, False);
>-    return reps;
>-}
>-
>-int InitDashedSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateSegments(xp, p, False);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes
>-	(xp->d, xp->bggc, 0, LineOnOffDash, CapNotLast, JoinMiter);
>-    XSetLineAttributes
>-	(xp->d, xp->fggc, 0, LineOnOffDash, CapNotLast, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->fggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->bggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitDoubleDashedSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char dashes[2];
>-
>-    GenerateSegments(xp, p, True);
>-
>-    /* Modify GCs to draw dashed */
>-    XSetLineAttributes
>-	(xp->d, xp->ddbggc, 0, LineDoubleDash, CapNotLast, JoinMiter);
>-    XSetLineAttributes
>-	(xp->d, xp->ddfggc, 0, LineDoubleDash, CapNotLast, JoinMiter);
>-    dashes[0] = 3;   dashes[1] = 2;
>-    XSetDashes(xp->d, xp->ddfggc, 0, dashes, 2);
>-    XSetDashes(xp->d, xp->ddbggc, 0, dashes, 2);
>-    return reps;
>-}
>-
>-int InitHorizSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     size;
>-    int     half;
>-    int     i;
>-    int     rows;       /* Number of rows filled in current column      */
>-    int     x, y;	/* base of square to draw in			*/
>-    int     y1;		/* y position inside square			*/
>-    int     inc;
>-    XGCValues   gcv;
>-
>-    pgc = xp->fggc;
>-
>-    size = p->special;
>-    half = (size + 19) / 20;
>-
>-    segments = (XSegment *)malloc((p->objects) * sizeof(XSegment));
>-
>-    x = half;
>-    y = half;
>-    y1 = 0;
>-    rows = 0;
>-    inc = size / p->objects;
>-    if (inc == 0) inc = 1;
>-
>-    for (i = 0; i != p->objects; i++) {
>-	if (i % 2) {
>-	    segments[i].x1 = x + size;
>-	    segments[i].x2 = x;
>-	    segments[i].y1 = y + size - y1;
>-	    segments[i].y2 = y + size - y1;
>-	    y1 += inc;
>-	    if (y1 >= size) y1 -= size;
>-	} else {
>-	    segments[i].x1 = x;
>-	    segments[i].x2 = x + size;
>-	    segments[i].y1 = y + y1;
>-	    segments[i].y2 = y + y1;
>-	}
>-	rows++;
>-	y += size;
>-	if (y >= HEIGHT - size - half || rows == MAXROWS) {
>-	    rows = 0;
>-	    y = half;
>-	    x += size;
>-	    if (x >= WIDTH - size - half)
>-		x = half;
>-	}
>-    }
>-    gcv.cap_style = CapNotLast;
>-    XChangeGC(xp->d, xp->fggc, GCCapStyle, &gcv);
>-    XChangeGC(xp->d, xp->bggc, GCCapStyle, &gcv);
>-    return reps;
>-}
>-
>-int InitWideHorizSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int size;
>-
>-    (void)InitHorizSegments(xp, p, reps);
>-
>-    size = p->special;
>-    XSetLineAttributes(xp->d, xp->bggc, (int) ((size + 9) / 10),
>-	LineSolid, CapRound, JoinRound);
>-    XSetLineAttributes(xp->d, xp->fggc, (int) ((size + 9) / 10),
>-	LineSolid, CapRound, JoinRound);
>-
>-    return reps;
>-}
>- 
>-
>-int InitVertSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     size;
>-    int     half;
>-    int     i;
>-    int     rows;       /* Number of rows filled in current column      */
>-    int     x, y;	/* base of square to draw in			*/
>-    int     x1;		/* x position inside square			*/
>-    int     inc;
>-    XGCValues   gcv;
>-
>-    pgc = xp->fggc;
>-
>-    size = p->special;
>-    half = (size + 19) / 20;
>-
>-    segments = (XSegment *)malloc((p->objects) * sizeof(XSegment));
>-
>-    x = half;
>-    y = half;
>-    x1 = 0;
>-    rows = 0;
>-    inc = size / p->objects;
>-    if (inc == 0) inc = 1;
>-
>-    for (i = 0; i != p->objects; i++) {
>-	if (i % 2) {
>-	    segments[i].x1 = x + size - x1;
>-	    segments[i].x2 = x + size - x1;
>-	    segments[i].y1 = y + size;
>-	    segments[i].y2 = y;
>-	    x1 += inc;
>-	    if (x1 >= size) x1 -= size;
>-	} else {
>-	    segments[i].x1 = x + x1;
>-	    segments[i].x2 = x + x1;
>-	    segments[i].y1 = y;
>-	    segments[i].y2 = y + size;
>-	}
>-	rows++;
>-	y += size;
>-	if (y >= HEIGHT - size - half || rows == MAXROWS) {
>-	    /* Go to next column */
>-	    rows = 0;
>-	    y = half;
>-	    x += size;
>-	    if (x >= WIDTH - size - half) {
>-		x = half;
>-	    }
>-	}
>-    }
>-    gcv.cap_style = CapNotLast;
>-    XChangeGC(xp->d, xp->fggc, GCCapStyle, &gcv);
>-    XChangeGC(xp->d, xp->bggc, GCCapStyle, &gcv);
>-    return reps;
>-}
>-
>-int InitWideVertSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int size;
>-
>-    (void)InitVertSegments(xp, p, reps);
>-
>-    size = p->special;
>-    XSetLineAttributes(xp->d, xp->bggc, (int) ((size + 9) / 10),
>-	LineSolid, CapRound, JoinRound);
>-    XSetLineAttributes(xp->d, xp->fggc, (int) ((size + 9) / 10),
>-	LineSolid, CapRound, JoinRound);
>-
>-    return reps;
>-}
>- 
>-
>-void DoSegments(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != reps; i++) {
>-        XDrawSegments(xp->d, xp->w, pgc, segments, p->objects);
>-        if (pgc == xp->ddbggc)
>-            pgc = xp->ddfggc;
>-        else if(pgc == xp->ddfggc)
>-            pgc = xp->ddbggc;
>-        else if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void EndSegments(xp, p)
>-    XParms  xp;
>-    Parms p;
>-{
>-    free(segments);
>-}
>-
>Index: xc/programs/x11perf/do_simple.c
>===================================================================
>RCS file: xc/programs/x11perf/do_simple.c
>diff -N xc/programs/x11perf/do_simple.c
>--- xc/programs/x11perf/do_simple.c	28 May 2002 01:48:44 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,116 +0,0 @@
>-/* $Xorg: do_simple.c,v 1.5 2000/11/30 12:20:45 pookie Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#ifndef VMS
>-#include <X11/Xatom.h>
>-#else
>-#include <decw$include/Xatom.h>
>-#endif
>-
>-#include "x11perf.h"
>-
>-static Atom XA_PK_TEMP;
>-static Window root;
>-
>-void DoNoOp(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i;
>-
>-    for (i = 0; i != reps; i++) {
>-	XNoOp(xp->d);
>-    }
>-}
>-
>-
>-void DoGetAtom(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    char    *atom;
>-    int     i;
>-
>-    for (i = 0; i != reps; i++) {
>-	atom = XGetAtomName (xp->d, 1);
>- 	XFree(atom); /* fix XBUG 6480 */
>-    }
>-}
>-
>-void DoQueryPointer(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i;
>-    Window  w;
>-    int     x;
>-    unsigned int m;
>-
>-    for (i = 0; i != reps; i++) {
>-	XQueryPointer (xp->d, xp->w, &w, &w, &x, &x, &x, &x, &m);
>-    }
>-}
>-
>-int InitGetProperty(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    long foo[4];
>-
>-    foo[0] = 41;
>-    foo[1] = 14;
>-    foo[2] = 37;
>-    foo[3] = 73;
>-    root = RootWindow (xp->d, 0);
>-    XA_PK_TEMP = XInternAtom (xp->d, "_PK_TEMP", False);
>-    XChangeProperty (
>-	    xp->d, xp->w, XA_PK_TEMP, XA_INTEGER, 32,
>-	    PropModeReplace, (unsigned char *)foo, 4);
>-    return reps;
>-}
>-
>-void DoGetProperty(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, status;
>-    int     actual_format;
>-    unsigned long actual_length, bytes_remaining;
>-    unsigned char *prop;
>-    
>-    Atom actual_type;
>-
>-    for (i = 0; i != reps; i++) {
>-	status = XGetWindowProperty (
>-		xp->d, xp->w, XA_PK_TEMP, 0, 4,
>-		False, AnyPropertyType, &actual_type, &actual_format,
>-		&actual_length, &bytes_remaining, &prop);
>-	XFree(prop);
>-    }
>-}
>Index: xc/programs/x11perf/do_tests.c
>===================================================================
>RCS file: xc/programs/x11perf/do_tests.c
>diff -N xc/programs/x11perf/do_tests.c
>--- xc/programs/x11perf/do_tests.c	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,1297 +0,0 @@
>-/* $Xorg: do_tests.c,v 1.3 2000/08/17 19:54:10 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-extern void DoGetAtom();
>-extern void DoQueryPointer();
>-
>-extern void DoNoOp();
>-
>-extern Bool InitGetProperty();
>-extern void DoGetProperty();
>-
>-extern Bool InitRectangles();
>-extern void DoRectangles();
>-extern void DoOutlineRectangles();
>-extern void EndRectangles();
>-
>-extern Bool InitGC();
>-extern void DoChangeGC();
>-extern void EndGC();
>-
>-extern Bool InitSegments();
>-extern Bool InitHorizSegments();
>-extern Bool InitVertSegments();
>-extern Bool InitWideHorizSegments();
>-extern Bool InitWideVertSegments();
>-extern Bool InitDashedSegments();
>-extern Bool InitDoubleDashedSegments();
>-extern void DoSegments();
>-extern void EndSegments();
>-
>-extern Bool InitLines();
>-extern Bool InitWideLines();
>-extern Bool InitDashedLines();
>-extern Bool InitWideDashedLines();
>-extern Bool InitDoubleDashedLines();
>-extern Bool InitWideDoubleDashedLines();
>-extern void DoLines();
>-extern void EndLines();
>-
>-
>-extern Bool InitCircles();
>-extern Bool InitPartCircles();
>-extern Bool InitWideCircles();
>-extern Bool InitPartWideCircles();
>-extern Bool InitDashedCircles();
>-extern Bool InitWideDashedCircles();
>-extern Bool InitDoubleDashedCircles();
>-extern Bool InitWideDoubleDashedCircles();
>-extern Bool InitChordPartCircles();
>-extern Bool InitSlicePartCircles();
>-
>-extern Bool InitEllipses();
>-extern Bool InitPartEllipses();
>-extern Bool InitWideEllipses();
>-extern Bool InitPartWideEllipses();
>-extern Bool InitDashedEllipses();
>-extern Bool InitWideDashedEllipses();
>-extern Bool InitDoubleDashedEllipses();
>-extern Bool InitWideDoubleDashedEllipses();
>-extern Bool InitChordPartEllipses();
>-extern Bool InitSlicePartEllipses();
>-extern void DoArcs();
>-extern void DoFilledArcs();
>-extern void EndArcs();
>-
>-extern Bool InitDots();
>-extern void DoDots();
>-extern void EndDots();
>-
>-extern Bool InitCreate();
>-extern void CreateChildren();
>-extern void DestroyChildren();
>-extern void EndCreate();
>-
>-extern Bool InitMap();
>-extern void MapParents();
>-extern void UnmapParents();
>-
>-extern Bool InitDestroy();
>-extern void DestroyParents();
>-extern void RenewParents();
>-
>-extern Bool InitMoveWindows();
>-extern void DoMoveWindows();
>-extern void EndMoveWindows();
>-
>-extern void DoResizeWindows();
>-
>-extern Bool InitCircWindows();
>-extern void DoCircWindows();
>-extern void EndCircWindows();
>-
>-extern Bool InitMoveTree();
>-extern void DoMoveTree();
>-extern void EndMoveTree();
>-
>-extern Bool InitText();
>-extern Bool InitText16();
>-extern void DoText();
>-extern void DoText16();
>-extern void DoImageText();
>-extern void DoImageText16();
>-extern void DoPolyText();
>-extern void DoPolyText16();
>-extern void ClearTextWin();
>-extern void EndText();
>-extern void EndText16();
>-
>-extern Bool InitCopyPlane();
>-extern void DoCopyPlane();
>-extern void EndCopyPlane();
>-
>-extern Bool InitPopups();
>-extern void DoPopUps();
>-extern void EndPopups();
>-
>-extern Bool InitScroll();
>-extern void DoScroll();
>-extern void MidScroll();
>-extern void EndScroll();
>-
>-extern Bool InitCopyWin();
>-extern Bool InitCopyPix();
>-extern void DoCopyWinWin();
>-extern void DoCopyPixWin();
>-extern void DoCopyWinPix();
>-extern void DoCopyPixPix();
>-extern void MidCopyPix();
>-extern void EndCopyWin();
>-extern void EndCopyPix();
>-
>-extern Bool InitGetImage();
>-extern void DoGetImage();
>-extern void EndGetImage();
>-
>-extern Bool InitPutImage();
>-extern void DoPutImage();
>-
>-#ifdef MITSHM
>-extern Bool InitShmPutImage();
>-extern void DoShmPutImage();
>-extern void EndShmPutImage();
>-#endif
>-
>-extern Bool InitTriangles();
>-extern void DoTriangles();
>-extern void EndTriangles();
>-
>-extern Bool InitTrapezoids();
>-extern void DoTrapezoids();
>-extern void EndTrapezoids();
>-
>-extern Bool InitComplexPoly();
>-extern void DoComplexPoly();
>-extern void EndComplexPoly();
>-
>-extern Bool InitGeneralPoly();
>-extern void DoGeneralPoly();
>-
>-/*
>- * some test must be done a certain multiple of times. That multiple is
>- * in the second half of the products below. You can edit the multiplier,
>- * just not the multiplicand.
>- */
>-
>-Test test[] = {
>-  {"-dot",      "Dot", NULL,
>-		InitDots, DoDots, NullProc, EndDots,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY}},
>-  {"-rect1",    "1x1 rectangle", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1, NULL, NULL, FillSolid}},
>-  {"-rect10",   "10x10 rectangle", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, NULL, NULL, FillSolid}},
>-  {"-rect100",  "100x100 rectangle", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{36, 100, NULL, NULL, FillSolid}},
>-  {"-rect500",  "500x500 rectangle", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 500, NULL, NULL, FillSolid}},
>-  {"-srect1",  "1x1 stippled rectangle",
>-		"1x1 stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1, NULL, NULL, FillStippled}},
>-  {"-srect10", "10x10 stippled rectangle",
>-		"10x10 stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, NULL, NULL, FillStippled}},
>-  {"-srect100", "100x100 stippled rectangle",
>-		"100x100 stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{36, 100, NULL, NULL, FillStippled}},
>-  {"-srect500", "500x500 stippled rectangle",
>-		"500x500 stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 500, NULL, NULL, FillStippled}},
>-  {"-osrect1",  "1x1 opaque stippled rectangle",
>-		"1x1 opaque stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1, NULL, NULL, FillOpaqueStippled}},
>-  {"-osrect10", "10x10 opaque stippled rectangle",
>-		"10x10 opaque stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, NULL, NULL, FillOpaqueStippled}},
>-  {"-osrect100", "100x100 opaque stippled rectangle",
>-		"100x100 opaque stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{36, 100, NULL, NULL, FillOpaqueStippled}},
>-  {"-osrect500", "500x500 opaque stippled rectangle",
>-		"500x500 opaque stippled rectangle (8x8 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 500, NULL, NULL, FillOpaqueStippled}},
>-  {"-tilerect1", "1x1 4x4 tiled rectangle",
>-		"1x1 tiled rectangle (4x4 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1, NULL, NULL, FillTiled}},
>-  {"-tilerect10", "10x10 4x4 tiled rectangle",
>-		"10x10 tiled rectangle (4x4 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, NULL, NULL, FillTiled}},
>-  {"-tilerect100", "100x100 4x4 tiled rectangle",
>-		"100x100 tiled rectangle (4x4 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{36, 100, NULL, NULL, FillTiled}},
>-  {"-tilerect500", "500x500 4x4 tiled rectangle",
>-		"500x500 tiled rectangle (4x4 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 500, NULL, NULL, FillTiled}},
>-  {"-oddsrect1",  "1x1 stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "OddTile", NULL, FillStippled}},
>-  {"-oddsrect10", "10x10 stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, "OddTile", NULL, FillStippled}},
>-  {"-oddsrect100", "100x100 stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{36, 100, "OddTile", NULL, FillStippled}},
>-  {"-oddsrect500", "500x500 stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{1, 500, "OddTile", NULL, FillStippled}},
>-  {"-oddosrect1",  "1x1 opaque stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddosrect10", "10x10 opaque stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddosrect100", "100x100 opaque stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{36, 100, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddosrect500", "500x500 opaque stippled rectangle (17x15 stipple)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{1, 500, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddtilerect1", "1x1 tiled rectangle (17x15 tile)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "OddTile", NULL, FillTiled}},
>-  {"-oddtilerect10", "10x10 tiled rectangle (17x15 tile)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, "OddTile", NULL, FillTiled}},
>-  {"-oddtilerect100", "100x100 tiled rectangle (17x15 tile)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{36, 100, "OddTile", NULL, FillTiled}},
>-  {"-oddtilerect500", "500x500 tiled rectangle (17x15 tile)", NULL,
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_4FEATURE, ROP, 0,
>-		{1, 500, "OddTile", NULL, FillTiled}},
>-  {"-bigsrect1",  "1x1 161x145 stippled rectangle",
>-		"1x1 stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 1, "mensetmanus", NULL, FillStippled}},
>-  {"-bigsrect10", "10x10 161x145 stippled rectangle",
>-		"10x10 stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, "mensetmanus", NULL, FillStippled}},
>-  {"-bigsrect100", "100x100 161x145 stippled rectangle",
>-		"100x100 stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{36, 100, "mensetmanus", NULL, FillStippled}},
>-  {"-bigsrect500", "500x500 161x145 stippled rectangle",
>-		"500x500 stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{1, 500, "mensetmanus", NULL, FillStippled}},
>-  {"-bigosrect1",  "1x1 161x145 opaque stippled rectangle",
>-		"1x1 opaque stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 1, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigosrect10", "10x10 161x145 opaque stippled rectangle",
>-		"10x10 opaque stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigosrect100", "100x100 161x145 opaque stippled rectangle",
>-		"100x100 opaque stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{36, 100, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigosrect500", "500x500 161x145 opaque stippled rectangle",
>-		"500x500 opaque stippled rectangle (161x145 stipple)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{1, 500, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigtilerect1", "1x1 161x145 tiled rectangle",
>-		"1x1 tiled rectangle (161x145 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1, "mensetmanus", NULL, FillTiled}},
>-  {"-bigtilerect10", "10x10 161x145 tiled rectangle",
>-		"10x10 tiled rectangle (161x145 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, "mensetmanus", NULL, FillTiled}},
>-  {"-bigtilerect100", "100x100 161x145 tiled rectangle",
>-		"100x100 tiled rectangle (161x145 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{36, 100, "mensetmanus", NULL, FillTiled}},
>-  {"-bigtilerect500", "500x500 161x145 tiled rectangle",
>-		"500x500 tiled rectangle (161x145 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 500, "mensetmanus", NULL, FillTiled}},
>-  {"-eschertilerect1", "1x1 216x208 tiled rectangle",
>-		"1x1 tiled rectangle (216x208 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 1, "escherknot", NULL, FillTiled}},
>-  {"-eschertilerect10", "10x10 216x208 tiled rectangle",
>-		"10x10 tiled rectangle (216x208 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, "escherknot", NULL, FillTiled}},
>-  {"-eschertilerect100", "100x100 216x208 tiled rectangle",
>-		"100x100 tiled rectangle (216x208 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{36, 100, "escherknot", NULL, FillTiled}},
>-  {"-eschertilerect500", "500x500 216x208 tiled rectangle",
>-		"500x500 tiled rectangle (216x208 tile)",
>-		InitRectangles, DoRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{1, 500, "escherknot", NULL, FillTiled}},
>-  {"-seg1",     "1-pixel line segment", NULL,
>-		InitSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1}},
>-  {"-seg10",    "10-pixel line segment", NULL,
>-		InitSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-seg100",   "100-pixel line segment", NULL,
>-		InitSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-seg500",   "500-pixel line segment", NULL,
>-		InitSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 500}},
>-  {"-seg100c1", "100-pixel line segment (1 kid)", NULL,
>-		InitSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 1,
>-		{POLY, 100}},
>-  {"-seg100c2", "100-pixel line segment (2 kids)", NULL,
>-		InitSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 2,
>-		{POLY, 100}},
>-  {"-seg100c3", "100-pixel line segment (3 kids)", NULL,
>-		InitSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 3,
>-		{POLY, 100}},
>-  {"-dseg10",   "10-pixel dashed segment", NULL,
>-		InitDashedSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-dseg100", "100-pixel dashed segment", NULL,
>-		InitDashedSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-ddseg100", "100-pixel double-dashed segment", NULL,
>-		InitDoubleDashedSegments, DoSegments, NullProc, EndSegments,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-hseg10",   "10-pixel horizontal line segment", NULL,
>-		InitHorizSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-hseg100",  "100-pixel horizontal line segment", NULL,
>-		InitHorizSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-hseg500",  "500-pixel horizontal line segment", NULL,
>-		InitHorizSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 500}},
>-  {"-vseg10",   "10-pixel vertical line segment", NULL,
>-		InitVertSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-vseg100",  "100-pixel vertical line segment", NULL,
>-		InitVertSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-vseg500",  "500-pixel vertical line segment", NULL,
>-		InitVertSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 500}},
>-  {"-whseg10",  "10x1 wide horizontal line segment", NULL,
>-		InitWideHorizSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{200, 10}},
>-  {"-whseg100", "100x10 wide horizontal line segment", NULL,
>-		InitWideHorizSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-whseg500", "500x50 wide horizontal line segment", NULL,
>-		InitWideHorizSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{50, 500}},
>-  {"-wvseg10",  "10x1 wide vertical line segment", NULL,
>-		InitWideVertSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{200, 10}},
>-  {"-wvseg100", "100x10 wide vertical line segment", NULL,
>-		InitWideVertSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-wvseg500", "500x50 wide vertical line segment", NULL,
>-		InitWideVertSegments, DoSegments, NullProc, EndSegments,
>-		V1_3FEATURE, ROP, 0,
>-		{50, 500}},
>-  {"-line1",   "1-pixel line", NULL,
>-		InitLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1}},
>-  {"-line10",   "10-pixel line", NULL,
>-		InitLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-line100",  "100-pixel line", NULL,
>-		InitLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-line500", "500-pixel line", NULL,
>-		InitLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 500}},
>-  {"-dline10",  "10-pixel dashed line", NULL,
>-		InitDashedLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-dline100", "100-pixel dashed line", NULL,
>-		InitDashedLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-ddline100", "100-pixel double-dashed line", NULL,
>-		InitDoubleDashedLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 100}},
>-  {"-wline10",  "10x1 wide line", NULL,
>-		InitWideLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 10}},
>-  {"-wline100", "100x10 wide line", NULL,
>-		InitWideLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-wline500", "500x50 wide line", NULL,
>-		InitWideLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{50, 500}},
>-  {"-wdline100", "100x10 wide dashed line", NULL,
>-		InitWideDashedLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-wddline100",  "100x10 wide double-dashed line", NULL,
>-		InitWideDoubleDashedLines, DoLines, NullProc, EndLines,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-orect10",  "10x10 rectangle outline", NULL,
>-		InitRectangles, DoOutlineRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, NULL, "0", FillSolid}},
>-  {"-orect100", "100x100 rectangle outline", NULL,
>-		InitRectangles, DoOutlineRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{36, 100, NULL, "0", FillSolid}},
>-  {"-orect500",	"500x500 rectangle outline", NULL,
>-		InitRectangles, DoOutlineRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{1, 500, NULL, "0", FillSolid}},
>-  {"-worect10",	"10x10 wide rectangle outline", NULL,
>-		InitRectangles, DoOutlineRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, NULL, "1", FillSolid}},
>-  {"-worect100", "100x100 wide rectangle outline", NULL,
>-		InitRectangles, DoOutlineRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{36, 100, NULL, "10", FillSolid}},
>-  {"-worect500", "500x500 wide rectangle outline", NULL,
>-		InitRectangles, DoOutlineRectangles, NullProc, EndRectangles,
>-		V1_3FEATURE, ROP, 0,
>-		{1, 500, NULL, "50", FillSolid}},
>-  {"-circle1",  "1-pixel circle", NULL,
>-		InitCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1}},
>-  {"-circle10", "10-pixel circle", NULL,
>-		InitCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-circle100", "100-pixel circle", NULL,
>-		InitCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{200, 100}},
>-  {"-circle500", "500-pixel circle", NULL,
>-		InitCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{50, 500}},
>-  {"-dcircle100", "100-pixel dashed circle", NULL,
>-		InitDashedCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-ddcircle100", "100-pixel double-dashed circle", NULL,
>-		InitDoubleDashedCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-wcircle10", "10-pixel wide circle", NULL,
>-		InitWideCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-wcircle100", "100-pixel wide circle", NULL,
>-		InitWideCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-wcircle500", "500-pixel wide circle", NULL,
>-		InitWideCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{25, 500}},
>-  {"-wdcircle100", "100-pixel wide dashed circle", NULL,
>-		InitWideDashedCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-wddcircle100", "100-pixel wide double-dashed circle", NULL,
>-		InitWideDoubleDashedCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-pcircle10", "10-pixel partial circle", NULL,
>-		InitPartCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-pcircle100", "100-pixel partial circle", NULL,
>-		InitPartCircles, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{198, 100}},
>-  {"-wpcircle10", "10-pixel wide partial circle", NULL,
>-		InitPartWideCircles, DoArcs, NullProc, EndArcs,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-wpcircle100", "100-pixel wide partial circle", NULL,
>-		InitPartWideCircles, DoArcs, NullProc, EndArcs,
>-		V1_3FEATURE, ROP, 0,
>-		{198, 100}},
>-  {"-fcircle1",  "1-pixel solid circle", NULL,
>-		InitCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 1}},
>-  {"-fcircle10", "10-pixel solid circle", NULL,
>-		InitCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-fcircle100", "100-pixel solid circle", NULL,
>-		InitCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-fcircle500", "500-pixel solid circle", NULL,
>-		InitCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{20, 500}},
>-  {"-fcpcircle10", "10-pixel fill chord partial circle", NULL,
>-		InitChordPartCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-fcpcircle100", "100-pixel fill chord partial circle", NULL,
>-		InitChordPartCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{108, 100}},
>-  {"-fspcircle10", "10-pixel fill slice partial circle", NULL,
>-		InitSlicePartCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-fspcircle100", "100-pixel fill slice partial circle", NULL,
>-		InitSlicePartCircles, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{108, 100}},
>-  {"-ellipse10", "10-pixel ellipse", NULL,
>-		InitEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{500, 10}},
>-  {"-ellipse100", "100-pixel ellipse", NULL,
>-		InitEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{300, 100}},
>-  {"-ellipse500", "500-pixel ellipse", NULL,
>-		InitEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 500}},
>-  {"-dellipse100", "100-pixel dashed ellipse", NULL,
>-		InitDashedEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{25, 100}},
>-  {"-ddellipse100", "100-pixel double-dashed ellipse", NULL,
>-		InitDoubleDashedEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{25, 100}},
>-  {"-wellipse10", "10-pixel wide ellipse", NULL,
>-		InitWideEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{200, 10}},
>-  {"-wellipse100", "100-pixel wide ellipse", NULL,
>-		InitWideEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{25, 100}},
>-  {"-wellipse500", "500-pixel wide ellipse", NULL,
>-		InitWideEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{20, 500}},
>-  {"-wdellipse100", "100-pixel wide dashed ellipse", NULL,
>-		InitWideDashedEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{25, 100}},
>-  {"-wddellipse100", "100-pixel wide double-dashed ellipse", NULL,
>-		InitWideDoubleDashedEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{25, 100}},
>-  {"-pellipse10", "10-pixel partial ellipse", NULL,
>-		InitPartEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{540, 10}},
>-  {"-pellipse100", "100-pixel partial ellipse", NULL,
>-		InitPartEllipses, DoArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{360, 100}},
>-  {"-wpellipse10", "10-pixel wide partial ellipse", NULL,
>-		InitPartWideEllipses, DoArcs, NullProc, EndArcs,
>-		V1_3FEATURE, ROP, 0,
>-		{540, 10}},
>-  {"-wpellipse100", "100-pixel wide partial ellipse", NULL,
>-		InitPartWideEllipses, DoArcs, NullProc, EndArcs,
>-		V1_3FEATURE, ROP, 0,
>-		{360, 100}},
>-  {"-fellipse10", "10-pixel filled ellipse", NULL,
>-		InitEllipses, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{200, 10}},
>-  {"-fellipse100", "100-pixel filled ellipse", NULL,
>-		InitEllipses, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{25, 100}},
>-  {"-fellipse500", "500-pixel filled ellipse", NULL,
>-		InitEllipses, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{10, 500}},
>-  {"-fcpellipse10", "10-pixel fill chord partial ellipse", NULL,
>-		InitChordPartEllipses, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{270, 10}},
>-  {"-fcpellipse100", "100-pixel fill chord partial ellipse", NULL,
>-		InitChordPartEllipses, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{36, 100}},
>-  {"-fspellipse10", "10-pixel fill slice partial ellipse", NULL,
>-		InitSlicePartEllipses, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{270, 10}},
>-  {"-fspellipse100", "100-pixel fill slice partial ellipse", NULL,
>-		InitSlicePartEllipses, DoFilledArcs, NullProc, EndArcs,
>-		V1_2FEATURE, ROP, 0,
>-		{36, 100}},
>-  {"-triangle1", "Fill 1-pixel/side triangle", NULL,
>-		InitTriangles, DoTriangles, NullProc, EndTriangles,
>-		V1_2ONLY, ROP, 0,
>-		{POLY, 1}},
>-  {"-triangle10", "Fill 10-pixel/side triangle", NULL,
>-		InitTriangles, DoTriangles, NullProc, EndTriangles,
>-		V1_2ONLY, ROP, 0,
>-		{POLY, 10}},
>-  {"-triangle100", "Fill 100-pixel/side triangle", NULL,
>-		InitTriangles, DoTriangles, NullProc, EndTriangles,
>-		V1_2ONLY, ROP, 0,
>-		{100, 100}},
>-  {"-triangle1", "Fill 1x1 equivalent triangle", NULL,
>-		InitTriangles, DoTriangles, NullProc, EndTriangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 1}},
>-  {"-triangle10", "Fill 10x10 equivalent triangle", NULL,
>-		InitTriangles, DoTriangles, NullProc, EndTriangles,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-triangle100", "Fill 100x100 equivalent triangle", NULL,
>-		InitTriangles, DoTriangles, NullProc, EndTriangles,
>-		V1_3FEATURE, ROP, 0,
>-		{100, 100}},
>-  {"-trap1", "Fill 1x1 trapezoid", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1}},
>-  {"-trap10", "Fill 10x10 trapezoid", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-trap100", "Fill 100x100 trapezoid", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY/10, 100}},
>-  {"-trap300", "Fill 300x300 trapezoid", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300}},
>-  {"-strap1", "Fill 1x1 stippled trapezoid (8x8 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, NULL, NULL, FillStippled}},
>-  {"-strap10", "Fill 10x10 stippled trapezoid",
>-		"Fill 10x10 stippled trapezoid (8x8 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, NULL, NULL, FillStippled}},
>-  {"-strap100", "Fill 100x100 stippled trapezoid",
>-		"Fill 100x100 stippled trapezoid (8x8 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100, NULL, NULL, FillStippled}},
>-  {"-strap300", "Fill 300x300 stippled trapezoid (8x8 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, NULL, NULL, FillStippled}},
>-  {"-ostrap1", "Fill 1x1 opaque stippled trapezoid (8x8 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, NULL, NULL, FillOpaqueStippled}},
>-  {"-ostrap10", "Fill 10x10 opaque stippled trapezoid",
>-		"Fill 10x10 opaque stippled trapezoid (8x8 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, NULL, NULL, FillOpaqueStippled}},
>-  {"-ostrap100", "Fill 100x100 opaque stippled trapezoid",
>-		"Fill 100x100 opaque stippled trapezoid (8x8 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100, NULL, NULL, FillOpaqueStippled}},
>-  {"-ostrap300", "Fill 300x300 opaque stippled trapezoid (8x8 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, NULL, NULL, FillOpaqueStippled}},
>-  {"-tiletrap1", "Fill 1x1 tiled trapezoid (4x4 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, NULL, NULL, FillTiled}},
>-  {"-tiletrap10", "Fill 10x10 tiled trapezoid",
>-		"Fill 10x10 tiled trapezoid (4x4 tile)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{POLY, 10, NULL, NULL, FillTiled}},
>-  {"-tiletrap100", "Fill 100x100 tiled trapezoid",
>-		"Fill 100x100 tiled trapezoid (4x4 tile)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_2FEATURE, ROP, 0,
>-		{100, 100, NULL, NULL, FillTiled}},
>-  {"-tiletrap300", "Fill 300x300 tiled trapezoid (4x4 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, NULL, NULL, FillTiled}},
>-  {"-oddstrap1", "Fill 1x1 stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "OddTile", NULL, FillStippled}},
>-  {"-oddstrap10", "Fill 10x10 stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, "OddTile", NULL, FillStippled}},
>-  {"-oddstrap100", "Fill 100x100 stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{100, 100, "OddTile", NULL, FillStippled}},
>-  {"-oddstrap300", "Fill 300x300 stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, "OddTile", NULL, FillStippled}},
>-  {"-oddostrap1", "Fill 1x1 opaque stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddostrap10", "Fill 10x10 opaque stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddostrap100", "Fill 100x100 opaque stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{100, 100, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddostrap300", "Fill 300x300 opaque stippled trapezoid (17x15 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, "OddTile", NULL, FillOpaqueStippled}},
>-  {"-oddtiletrap1", "Fill 1x1 tiled trapezoid (17x15 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "OddTile", NULL, FillTiled}},
>-  {"-oddtiletrap10", "Fill 10x10 tiled trapezoid (17x15 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, "OddTile", NULL, FillTiled}},
>-  {"-oddtiletrap100", "Fill 100x100 tiled trapezoid (17x15 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{100, 100, "OddTile", NULL, FillTiled}},
>-  {"-oddtiletrap300", "Fill 300x300 tiled trapezoid (17x15 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, "OddTile", NULL, FillTiled}},
>-  {"-bigstrap1", "Fill 1x1 stippled trapezoid (161x145 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "mensetmanus", NULL, FillStippled}},
>-  {"-bigstrap10", "Fill 10x10 161x145 stippled trapezoid",
>-		"Fill 10x10 stippled trapezoid (161x145 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, "mensetmanus", NULL, FillStippled}},
>-  {"-bigstrap100", "Fill 100x100 161x145 stippled trapezoid",
>-		"Fill 100x100 stippled trapezoid (161x145 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{100, 100, "mensetmanus", NULL, FillStippled}},
>-  {"-bigstrap300", "Fill 300x300 stippled trapezoid (161x145 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, "mensetmanus", NULL, FillStippled}},
>-  {"-bigostrap1", "Fill 1x1 opaque stippled trapezoid (161x145 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigostrap10", "Fill 10x10 161x145 opaque stippled trapezoid",
>-		"Fill 10x10 opaque stippled trapezoid (161x145 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigostrap100", "Fill 100x100 161x145 opaque stippled trapezoid",
>-		"Fill 100x100 opaque stippled trapezoid (161x145 stipple)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{100, 100, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigostrap300", "Fill 300x300 opaque stippled trapezoid (161x145 stipple)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, "mensetmanus", NULL, FillOpaqueStippled}},
>-  {"-bigtiletrap1", "Fill 1x1 tiled trapezoid (161x145 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "mensetmanus", NULL, FillTiled}},
>-  {"-bigtiletrap10", "Fill 10x10 161x145 tiled trapezoid",
>-		"Fill 10x10 tiled trapezoid (161x145 tile)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, "mensetmanus", NULL, FillTiled}},
>-  {"-bigtiletrap100", "Fill 100x100 161x145 tiled trapezoid",
>-		"Fill 100x100 tiled trapezoid (161x145 tile)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{100, 100, "mensetmanus", NULL, FillTiled}},
>-  {"-bigtiletrap300", "Fill 300x300 tiled trapezoid (161x145 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, "mensetmanus", NULL, FillTiled}},
>-  {"-eschertiletrap1", "Fill 1x1 tiled trapezoid (216x208 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 1, "escherknot", NULL, FillTiled}},
>-  {"-eschertiletrap10", "Fill 10x10 216x208 tiled trapezoid",
>-		"Fill 10x10 tiled trapezoid (216x208 tile)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10, "escherknot", NULL, FillTiled}},
>-  {"-eschertiletrap100", "Fill 100x100 216x208 tiled trapezoid",
>-		"Fill 100x100 tiled trapezoid (216x208 tile)",
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_3FEATURE, ROP, 0,
>-		{36, 100, "escherknot", NULL, FillTiled}},
>-  {"-eschertiletrap300", "Fill 300x300 tiled trapezoid (216x208 tile)", NULL,
>-		InitTrapezoids, DoTrapezoids, NullProc, EndTrapezoids,
>-		V1_4FEATURE, ROP, 0,
>-		{2, 300, "escherknot", NULL, FillTiled}},
>-  {"-complex10", "Fill 10-pixel/side complex polygon", NULL,
>-		InitComplexPoly, DoComplexPoly, NullProc, EndComplexPoly,
>-		V1_2ONLY, ROP, 0,
>-		{POLY, 10}},
>-  {"-complex100", "Fill 100-pixel/side complex polygons", NULL,
>-		InitComplexPoly, DoComplexPoly, NullProc, EndComplexPoly,
>-		V1_2ONLY, ROP, 0,
>-		{POLY/10, 100}},
>-  {"-complex10", "Fill 10x10 equivalent complex polygon", NULL,
>-		InitComplexPoly, DoComplexPoly, NullProc, EndComplexPoly,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY, 10}},
>-  {"-complex100", "Fill 100x100 equivalent complex polygons", NULL,
>-		InitComplexPoly, DoComplexPoly, NullProc, EndComplexPoly,
>-		V1_3FEATURE, ROP, 0,
>-		{POLY/10, 100}},
>-  {"-64poly10convex", "Fill 10x10 64-gon (Convex)", NULL,
>-		InitGeneralPoly, DoGeneralPoly, NullProc, EndComplexPoly,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, (char *) 64, (char *) Convex}},
>-  {"-64poly100convex", "Fill 100x100 64-gon (Convex)", NULL,
>-		InitGeneralPoly, DoGeneralPoly, NullProc, EndComplexPoly,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY/10, 100, (char *) 64, (char *) Convex}},
>-  {"-64poly10complex", "Fill 10x10 64-gon (Complex)", NULL,
>-		InitGeneralPoly, DoGeneralPoly, NullProc, EndComplexPoly,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY, 10, (char *) 64, (char *) Complex}},
>-  {"-64poly100complex", "Fill 100x100 64-gon (Complex)", NULL,
>-		InitGeneralPoly, DoGeneralPoly, NullProc, EndComplexPoly,
>-		V1_4FEATURE, ROP, 0,
>-		{POLY/10, 100, (char *) 64, (char *) Complex}},
>-  {"-ftext",    "Char in 80-char line (6x13)", NULL,
>-		InitText, DoText, ClearTextWin, EndText,
>-		V1_2FEATURE, ROP, 0,
>-		{80, False, "6x13", NULL}},
>-  {"-f8text",    "Char in 70-char line (8x13)", NULL,
>-		InitText, DoText, ClearTextWin, EndText,
>-		V1_3FEATURE, ROP, 0,
>-		{70, False, "8x13", NULL}},
>-  {"-f9text",    "Char in 60-char line (9x15)", NULL,
>-		InitText, DoText, ClearTextWin, EndText,
>-		V1_3FEATURE, ROP, 0,
>-		{60, False, "9x15", NULL}},
>-  {"-f14text16",  "Char16 in 40-char line (k14)", NULL,
>-		InitText16, DoText16, ClearTextWin, EndText16,
>-		V1_3FEATURE, ROP, 0,
>-		{40, False,
>-	      "-misc-fixed-medium-r-normal--14-130-75-75-c-140-jisx0208.1983-*",
>-		NULL}},
>-  {"-f24text16",  "Char16 in 23-char line (k24)", NULL,
>-		InitText16, DoText16, ClearTextWin, EndText16,
>-		V1_3FEATURE, ROP, 0,
>-		{23, False, 
>-	      "-jis-fixed-medium-r-normal--24-230-75-75-c-240-jisx0208.1983-*",
>-		NULL}},
>-  {"-tr10text", "Char in 80-char line (TR 10)", NULL,
>-		InitText, DoText, ClearTextWin, EndText,
>-		V1_2FEATURE, ROP, 0,
>-		{80, False, 
>-		"-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1", 
>-		NULL}},
>-  {"-tr24text", "Char in 30-char line (TR 24)", NULL,
>-		InitText, DoText, ClearTextWin, EndText,
>-		V1_2FEATURE, ROP, 0,
>-		{30, False, 
>-		"-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1",
>- 		NULL}},
>-  {"-polytext", "Char in 20/40/20 line (6x13, TR 10)", NULL,
>-		InitText, DoPolyText, ClearTextWin, EndText,
>-		V1_2FEATURE, ROP, 0,
>-		{80, True, "6x13", 
>-		"-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1"}},
>-  {"-polytext16", "Char16 in 7/14/7 line (k14, k24)", NULL,
>-		InitText16, DoPolyText16, ClearTextWin, EndText16,
>-		V1_3FEATURE, ROP, 0,
>-		{28, True, 
>-	     "-misc-fixed-medium-r-normal--14-130-75-75-c-140-jisx0208.1983-*",
>-             "-jis-fixed-medium-r-normal--24-230-75-75-c-240-jisx0208.1983-*"}},
>-  {"-fitext",   "Char in 80-char image line (6x13)", NULL,
>-		InitText, DoImageText, ClearTextWin, EndText,
>-		V1_2FEATURE, PLANEMASK, 0,
>-		{80, False, "6x13", NULL}},
>-  {"-f8itext",   "Char in 70-char image line (8x13)", NULL,
>-		InitText, DoImageText, ClearTextWin, EndText,
>-		V1_3FEATURE, PLANEMASK, 0,
>-		{70, False, "8x13", NULL}},
>-  {"-f9itext",   "Char in 60-char image line (9x15)", NULL,
>-		InitText, DoImageText, ClearTextWin, EndText,
>-		V1_3FEATURE, PLANEMASK, 0,
>-		{60, False, "9x15", NULL}},
>-  {"-f14itext16", "Char16 in 40-char image line (k14)", NULL,
>-		InitText16, DoImageText16, ClearTextWin, EndText16,
>-		V1_3FEATURE, PLANEMASK, 0,
>-		{40, False,
>-	      "-misc-fixed-medium-r-normal--14-130-75-75-c-140-jisx0208.1983-*",
>-		NULL}},
>-  {"-f24itext16", "Char16 in 23-char image line (k24)", NULL,
>-		InitText16, DoImageText16, ClearTextWin, EndText16,
>-		V1_3FEATURE, PLANEMASK, 0,
>-		{23, False, 
>-	      "-jis-fixed-medium-r-normal--24-230-75-75-c-240-jisx0208.1983-*",
>-		NULL}},
>-  {"-tr10itext", "Char in 80-char image line (TR 10)", NULL,
>-		InitText, DoImageText, ClearTextWin, EndText,
>-		V1_2FEATURE, PLANEMASK, 0,
>-		{80, False, 
>-		"-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1", 
>-		NULL}},
>-  {"-tr24itext", "Char in 30-char image line (TR 24)", NULL,
>-		InitText, DoImageText, ClearTextWin, EndText,
>-		V1_2FEATURE, PLANEMASK, 0,
>-		{30, False, 
>-		"-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1",
>- 		NULL}},
>-  {"-scroll10", "Scroll 10x10 pixels", NULL,
>-		InitScroll, DoScroll, MidScroll, EndScroll,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 10}},
>-  {"-scroll100", "Scroll 100x100 pixels", NULL,
>-		InitScroll, DoScroll, MidScroll, EndScroll,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 100}},
>-  {"-scroll500", "Scroll 500x500 pixels", NULL,
>-		InitScroll, DoScroll, MidScroll, EndScroll,
>-		V1_2FEATURE, ROP, 0,
>-		{1, 500}},
>-  {"-copywinwin10", "Copy 10x10 from window to window", NULL,
>-		InitCopyWin, DoCopyWinWin, MidScroll, EndCopyWin,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 10}},
>-  {"-copywinwin100", "Copy 100x100 from window to window", NULL,
>-		InitCopyWin, DoCopyWinWin, MidScroll, EndCopyWin,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 100}},
>-  {"-copywinwin500", "Copy 500x500 from window to window", NULL,
>-		InitCopyWin, DoCopyWinWin, MidScroll, EndCopyWin,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 500}},
>-  {"-copypixwin10", "Copy 10x10 from pixmap to window", NULL,
>-		InitCopyPix, DoCopyPixWin, MidCopyPix, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 10}},
>-  {"-copypixwin100", "Copy 100x100 from pixmap to window", NULL,
>-		InitCopyPix, DoCopyPixWin, MidCopyPix, EndCopyPix, 
>-		V1_2FEATURE, ROP, 0,
>-		{4, 100}},
>-  {"-copypixwin500", "Copy 500x500 from pixmap to window", NULL,
>-		InitCopyPix, DoCopyPixWin, MidCopyPix, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 500}},
>-  {"-copywinpix10", "Copy 10x10 from window to pixmap", NULL,
>-		InitCopyPix, DoCopyWinPix, MidScroll, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 10}},
>-  {"-copywinpix100", "Copy 100x100 from window to pixmap", NULL,
>-		InitCopyPix, DoCopyWinPix, MidScroll, EndCopyPix, 
>-		V1_2FEATURE, ROP, 0,
>-		{4, 100}},
>-  {"-copywinpix500", "Copy 500x500 from window to pixmap", NULL,
>-		InitCopyPix, DoCopyWinPix, MidScroll, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 500}},
>-  {"-copypixpix10", "Copy 10x10 from pixmap to pixmap", NULL,
>-		InitCopyPix, DoCopyPixPix, NullProc, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 10}},
>-  {"-copypixpix100", "Copy 100x100 from pixmap to pixmap", NULL,
>-		InitCopyPix, DoCopyPixPix, NullProc, EndCopyPix, 
>-		V1_2FEATURE, ROP, 0,
>-		{4, 100}},
>-  {"-copypixpix500", "Copy 500x500 from pixmap to pixmap", NULL,
>-		InitCopyPix, DoCopyPixPix, NullProc, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 500}},
>-  {"-copyplane10", "Copy 10x10 1-bit deep plane", NULL,
>-		InitCopyPlane, DoCopyPlane, MidCopyPix, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 10}},
>-  {"-copyplane100", "Copy 100x100 1-bit deep plane", NULL,
>-		InitCopyPlane, DoCopyPlane, MidCopyPix, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 100}},
>-  {"-copyplane500", "Copy 500x500 1-bit deep plane", NULL,
>-		InitCopyPlane, DoCopyPlane, MidCopyPix, EndCopyPix,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 500}},
>-  {"-deepcopyplane10", "Copy 10x10 n-bit deep plane", NULL,
>-		InitCopyPlane, DoCopyPlane, MidCopyPix, EndCopyPix,
>-		V1_5FEATURE, ROP, 0,
>-		{4, 10, "Deep"}},
>-  {"-deepcopyplane100", "Copy 100x100 n-bit deep plane", NULL,
>-		InitCopyPlane, DoCopyPlane, MidCopyPix, EndCopyPix,
>-		V1_5FEATURE, ROP, 0,
>-		{4, 100, "Deep"}},
>-  {"-deepcopyplane500", "Copy 500x500 n-bit deep plane", NULL,
>-		InitCopyPlane, DoCopyPlane, MidCopyPix, EndCopyPix,
>-		V1_5FEATURE, ROP, 0,
>-		{4, 500, "Deep"}},
>-  {"-putimage10", "PutImage 10x10 square", NULL,
>-		InitPutImage, DoPutImage, MidCopyPix, EndGetImage,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 10}},
>-  {"-putimage100", "PutImage 100x100 square", NULL,
>-		InitPutImage, DoPutImage, MidCopyPix, EndGetImage,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 100}},
>-  {"-putimage500", "PutImage 500x500 square", NULL,
>-		InitPutImage, DoPutImage, MidCopyPix, EndGetImage,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 500}},
>-  {"-putimagexy10", "PutImage XY 10x10 square", NULL,
>-		InitPutImage, DoPutImage, MidCopyPix, EndGetImage,
>-		V1_4FEATURE, ROP, 0,
>-		{4, 10, "XY"}},
>-  {"-putimagexy100", "PutImage XY 100x100 square", NULL,
>-		InitPutImage, DoPutImage, MidCopyPix, EndGetImage,
>-		V1_4FEATURE, ROP, 0,
>-		{4, 100, "XY"}},
>-  {"-putimagexy500", "PutImage XY 500x500 square", NULL,
>-		InitPutImage, DoPutImage, MidCopyPix, EndGetImage,
>-		V1_4FEATURE, ROP, 0,
>-		{4, 500, "XY"}},
>-#ifdef MITSHM
>-  {"-shmput10", "ShmPutImage 10x10 square", NULL,
>-		InitShmPutImage, DoShmPutImage, MidCopyPix, EndShmPutImage,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 10}},
>-  {"-shmput100", "ShmPutImage 100x100 square", NULL,
>-		InitShmPutImage, DoShmPutImage, MidCopyPix, EndShmPutImage,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 100}},
>-  {"-shmput500", "ShmPutImage 500x500 square", NULL,
>-		InitShmPutImage, DoShmPutImage, MidCopyPix, EndShmPutImage,
>-		V1_2FEATURE, ROP, 0,
>-		{4, 500}},
>-  {"-shmputxy10", "ShmPutImage XY 10x10 square", NULL,
>-		InitShmPutImage, DoShmPutImage, MidCopyPix, EndShmPutImage,
>-		V1_4FEATURE, ROP, 0,
>-		{4, 10, "XY"}},
>-  {"-shmputxy100", "ShmPutImage XY 100x100 square", NULL,
>-		InitShmPutImage, DoShmPutImage, MidCopyPix, EndShmPutImage,
>-		V1_4FEATURE, ROP, 0,
>-		{4, 100, "XY"}},
>-  {"-shmputxy500", "ShmPutImage XY 500x500 square", NULL,
>-		InitShmPutImage, DoShmPutImage, MidCopyPix, EndShmPutImage,
>-		V1_4FEATURE, ROP, 0,
>-		{4, 500, "XY"}},
>-#endif
>-  {"-getimage10", "GetImage 10x10 square", NULL,
>-		InitGetImage, DoGetImage, NullProc, EndGetImage,
>-		V1_2FEATURE, PLANEMASK, 0,
>-		{4, 10}},
>-  {"-getimage100", "GetImage 100x100 square", NULL,
>-		InitGetImage, DoGetImage, NullProc, EndGetImage,
>-		V1_2FEATURE, PLANEMASK, 0,
>-		{4, 100}},
>-  {"-getimage500", "GetImage 500x500 square", NULL,
>-		InitGetImage, DoGetImage, NullProc, EndGetImage,
>-		V1_2FEATURE, PLANEMASK, 0,
>-		{4, 500}},
>-  {"-getimagexy10", "GetImage XY 10x10 square", NULL,
>-		InitGetImage, DoGetImage, NullProc, EndGetImage,
>-		V1_4FEATURE, PLANEMASK, 0,
>-		{4, 10, "XY"}},
>-  {"-getimagexy100", "GetImage XY 100x100 square", NULL,
>-		InitGetImage, DoGetImage, NullProc, EndGetImage,
>-		V1_4FEATURE, PLANEMASK, 0,
>-		{4, 100, "XY"}},
>-  {"-getimagexy500", "GetImage XY 500x500 square", NULL,
>-		InitGetImage, DoGetImage, NullProc, EndGetImage,
>-		V1_4FEATURE, PLANEMASK, 0,
>-		{4, 500, "XY"}},
>-  {"-noop",     "X protocol NoOperation", NULL,
>-		NullInitProc, DoNoOp, NullProc, NullProc,
>-		V1_2FEATURE, PLANEMASK, 0,
>-		{1}},
>-  {"-atom",     "GetAtomName", NULL,
>-		NullInitProc, DoGetAtom, NullProc, NullProc,
>-		VERSION1_2 | VERSION1_3, NONROP, 0,
>-		{1}},
>-  {"-pointer",  "QueryPointer", NULL,
>-		NullInitProc, DoQueryPointer, NullProc, NullProc,
>-		V1_4FEATURE, NONROP, 0,
>-		{1}},
>-  {"-prop",     "GetProperty", NULL,
>-		InitGetProperty, DoGetProperty, NullProc, NullProc,
>-		V1_2FEATURE, NONROP, 0,
>-		{1}},
>-  {"-gc",       "Change graphics context", NULL,
>-		InitGC, DoChangeGC, NullProc, EndGC,
>-		V1_2FEATURE, NONROP, 0,
>-		{4}},
>-  {"-create",   "Create and map subwindows", NULL,
>-		InitCreate, CreateChildren, DestroyChildren, EndCreate,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, True}},
>-  {"-ucreate",  "Create unmapped window", NULL,
>-		InitCreate, CreateChildren, DestroyChildren, EndCreate,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, False}},
>-  {"-map",      "Map window via parent", NULL,
>-		InitMap, MapParents, UnmapParents, EndCreate,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, True}},
>-  {"-unmap",    "Unmap window via parent", NULL,
>-		InitDestroy, UnmapParents, MapParents, EndCreate,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, True}},
>-  {"-destroy",  "Destroy window via parent", NULL,
>-		InitDestroy, DestroyParents, RenewParents, EndCreate,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, True}},
>-  {"-popup",    "Hide/expose window via popup", NULL,
>-		InitPopups, DoPopUps, NullProc, EndPopups,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, True}},
>-  {"-move",     "Move window", NULL,
>-		InitMoveWindows, DoMoveWindows, NullProc, EndMoveWindows,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, True}},
>-  {"-umove",    "Moved unmapped window", NULL,
>-		InitMoveWindows, DoMoveWindows, NullProc, EndMoveWindows,
>-		V1_2FEATURE, WINDOW, 0,
>-		{0, False}},
>-  {"-movetree", "Move window via parent", NULL,
>-		InitMoveTree, DoMoveTree, NullProc, EndMoveTree,
>-		V1_2FEATURE, WINDOW, 0,
>-		{4, True}},
>-  {"-resize",   "Resize window", NULL,
>-		InitMoveWindows, DoResizeWindows, NullProc, EndMoveWindows,
>-		V1_2FEATURE, WINDOW, 0,
>-		{4, True}},
>-  {"-uresize",  "Resize unmapped window", NULL,
>-		InitMoveWindows, DoResizeWindows, NullProc, EndMoveWindows,
>-		V1_2FEATURE, WINDOW, 0,
>-		{4, False}},
>-  {"-circulate", "Circulate window", NULL,
>-		InitCircWindows, DoCircWindows, NullProc, EndCircWindows,
>-		V1_2FEATURE, WINDOW, 0,
>-		{4, True}},
>-  {"-ucirculate", "Circulate Unmapped window", NULL,
>-		InitCircWindows, DoCircWindows, NullProc, EndCircWindows,
>-		V1_2FEATURE, WINDOW, 0,
>-		{4, False}},
>-  { NULL, NULL, NULL,
>-		NULL, NULL, NULL, NULL,
>-		0, NONROP, 0,
>-		{0, False}}
>-};
>Index: xc/programs/x11perf/do_text.c
>===================================================================
>RCS file: xc/programs/x11perf/do_text.c
>diff -N xc/programs/x11perf/do_text.c
>--- xc/programs/x11perf/do_text.c	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,411 +0,0 @@
>-/* $Xorg: do_text.c,v 1.4 2000/08/17 19:54:10 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-static char **charBuf;
>-static XFontStruct *font, *bfont;
>-static int height, ypos;
>-static XTextItem *items;
>-static int charsPerLine, totalLines;
>-
>-#define XPOS 20
>-#define SEGS 3
>-
>-
>-int InitText(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		i, j;
>-    char	ch;
>-    XGCValues   gcv;
>-
>-    font = XLoadQueryFont(xp->d, p->font);
>-    if (font == NULL) {
>-	printf("Could not load font '%s', benchmark omitted\n", p->font);
>-	return 0;
>-    }
>-
>-    bfont = NULL;
>-    if (p->bfont != NULL) {
>-	bfont = XLoadQueryFont(xp->d, p->bfont);
>-	if (bfont == NULL) {
>-	    printf("Could not load font '%s', benchmark omitted\n", p->bfont);
>-	    return 0;
>-	}
>-    }
>-
>-    ypos = XPOS;
>-    height = (font->max_bounds.ascent + font->max_bounds.descent) + 1;
>-    if (bfont != NULL) {
>-	int     h = (bfont->max_bounds.ascent + bfont->max_bounds.descent) + 1;
>-	if (h > height)
>-	    height = h;
>-    }
>-    gcv.font = font->fid;
>-    XChangeGC(xp->d, xp->fggc, GCFont, &gcv);
>-    XChangeGC(xp->d, xp->bggc, GCFont, &gcv);
>-
>-    charsPerLine = p->objects;
>-    charsPerLine = (charsPerLine + 3) & ~3;
>-    p->objects = charsPerLine;
>-
>-    totalLines = '\177' - ' ' + 1;
>-    if (totalLines > reps) totalLines = reps;
>-
>-    charBuf = (char **) malloc(totalLines*sizeof (char *));
>-    if (p->special)
>-	items = (XTextItem *) malloc(totalLines*SEGS*sizeof (XTextItem));
>-
>-    for (i = 0; i != totalLines; i++) {
>-	charBuf[i] = (char *) malloc (sizeof (char)*charsPerLine);
>-	ch = i + ' ';
>-	for (j = 0; j != charsPerLine; j++) {
>-	    charBuf[i][j] = ch;
>-	    if (ch == '\177') ch = ' '; else ch++;
>-	}
>-	if (p->special) {
>-	    items[i*SEGS+0].chars = &(charBuf[i][0]);
>-	    items[i*SEGS+0].nchars = charsPerLine/4;
>-	    items[i*SEGS+0].delta = 0;
>-	    items[i*SEGS+0].font = font->fid;
>-	    items[i*SEGS+1].chars = &(charBuf[i][charsPerLine/4]);
>-	    items[i*SEGS+1].nchars = charsPerLine/2;
>-	    items[i*SEGS+1].delta = 3;
>-	    items[i*SEGS+1].font = bfont->fid;
>-	    items[i*SEGS+2].chars = &(charBuf[i][3*charsPerLine/4]);
>-	    items[i*SEGS+2].nchars = charsPerLine/4;
>-	    items[i*SEGS+2].delta = 3;
>-	    items[i*SEGS+2].font = font->fid;
>-	}
>-    }
>-    return reps;
>-}
>-
>-
>-#define GetRealChar(font, totalChars, ch)				\
>-{									\
>-    XCharStruct *pci;							\
>-    do {								\
>-	ch--;								\
>-	if (ch < 0) {							\
>-	    ch = totalChars-1;						\
>-	}								\
>-	if (font->per_char == NULL) break;				\
>-	pci = &(font->per_char[ch]);					\
>-    } while ( (pci->lbearing | pci->rbearing | pci->width		\
>-             | pci->ascent | pci->descent | pci->attributes) == 0);     \
>-} /* GetRealChar */
>-
>-int InitText16(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    register int	i, j;
>-    register char	*pbuf0, *pbuf1, *pbuf2;
>-    XGCValues   	gcv;
>-    int			rows, columns, totalChars, ch;
>-    int			brows, bcolumns, btotalChars, bch;
>-
>-    font = XLoadQueryFont(xp->d, p->font);
>-    if (font == NULL) {
>-	printf("Could not load font '%s', benchmark omitted\n", p->font);
>-	return 0;
>-    }
>-    rows = font->max_byte1 - font->min_byte1 + 1;
>-    columns = font->max_char_or_byte2 - font->min_char_or_byte2 + 1;
>-    totalChars = rows * columns;
>-    totalLines = rows;
>-    ch = totalChars;
>-
>-    bfont = NULL;
>-    if (p->bfont != NULL) {
>-	bfont = XLoadQueryFont(xp->d, p->bfont);
>-	if (bfont == NULL) {
>-	    printf("Could not load font '%s', benchmark omitted\n", p->bfont);
>-	    return 0;
>-	}
>-	brows = bfont->max_byte1 - bfont->min_byte1 + 1;
>-	bcolumns = bfont->max_char_or_byte2 - bfont->min_char_or_byte2 + 1;
>-	btotalChars = brows * bcolumns;
>-	bch = btotalChars;
>-	if (brows > totalLines) totalLines = brows;
>-    }
>-
>-    ypos = XPOS;
>-    height = (font->max_bounds.ascent + font->max_bounds.descent) + 1;
>-    if (bfont != NULL) {
>-	int     h = (bfont->max_bounds.ascent + bfont->max_bounds.descent) + 1;
>-	if (h > height)
>-	    height = h;
>-    }
>-    gcv.font = font->fid;
>-    XChangeGC(xp->d, xp->fggc, GCFont, &gcv);
>-    XChangeGC(xp->d, xp->bggc, GCFont, &gcv);
>-
>-    charsPerLine = p->objects;
>-
>-    if (totalLines > reps) totalLines = reps;
>-
>-    if (p->special) {
>-	charsPerLine = (charsPerLine + 3) & ~3;	/* make a multiple of four */
>-	p->objects = charsPerLine;
>-
>-	items = (XTextItem *) malloc(totalLines*SEGS*sizeof (XTextItem));
>-
>-	for (i = 0; i < totalLines; i++) {
>-	    pbuf0 = items[i*SEGS+0].chars =
>-			    (char *) malloc (sizeof (char)*charsPerLine/2);
>-	    items[i*SEGS+0].nchars = charsPerLine/4;
>-	    items[i*SEGS+0].delta = 0;
>-	    items[i*SEGS+0].font = font->fid;
>-	    pbuf1 = items[i*SEGS+1].chars =
>-			    (char *) malloc (sizeof (char)*charsPerLine);
>-	    items[i*SEGS+1].nchars = charsPerLine/2;
>-	    items[i*SEGS+1].delta = 3;
>-	    items[i*SEGS+1].font = bfont->fid;
>-	    pbuf2 = items[i*SEGS+2].chars =
>-			    (char *) malloc (sizeof (char)*charsPerLine/2);
>-	    items[i*SEGS+2].nchars = charsPerLine/4;
>-	    items[i*SEGS+2].delta = 3;
>-	    items[i*SEGS+2].font = font->fid;
>-	    for (j = 0; j < charsPerLine/4; j++) {
>-		GetRealChar(font, totalChars, ch);
>-		*pbuf0++ = ch / columns + font->min_byte1;
>-		*pbuf0++ = ch % columns + font->min_char_or_byte2;
>-		GetRealChar(font, totalChars, ch);
>-		*pbuf2++ = ch / columns + font->min_byte1;
>-		*pbuf2++ = ch % columns + font->min_char_or_byte2;
>-	    }
>-	    for (j = 0; j < charsPerLine/2; j++) {
>-		GetRealChar(bfont, btotalChars, bch);
>-		*pbuf1++ = bch / bcolumns + bfont->min_byte1;
>-		*pbuf1++ = bch % bcolumns + bfont->min_char_or_byte2;
>-	    }
>-	}
>-    } else {
>-	charBuf = (char **) malloc(totalLines*sizeof (char *));
>-	for (i = 0; i < totalLines; i++) {
>-	    pbuf0 = charBuf[i] = (char *) malloc (sizeof (char)*charsPerLine*2);
>-	    for (j = 0; j < charsPerLine; j++) {
>-		GetRealChar(font, totalChars, ch);
>-		*pbuf0++ = ch / columns + font->min_byte1;
>-		*pbuf0++ = ch % columns + font->min_char_or_byte2;
>-	    }
>-	}
>-    }
>-    return reps;
>-}
>-
>-void DoText(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, line, startLine;
>-
>-    startLine = 0;
>-    line = 0;
>-    for (i = 0; i != reps; i++) {
>-	XDrawString(
>-	    xp->d, xp->w, xp->fggc, XPOS, ypos, charBuf[line], charsPerLine);
>-	ypos += height;
>-	if (ypos > HEIGHT - height) {
>-	    /* Wraparound to top of window */
>-	    ypos = XPOS;
>-	    line = startLine;
>-	    startLine = (startLine + 1) % totalLines;
>-	}
>-	line = (line + 1) % totalLines;
>-    }
>-}
>-
>-void DoText16(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, line, startLine;
>-
>-    startLine = 0;
>-    line = 0;
>-    for (i = 0; i < reps; i++) {
>-	XDrawString16(
>-	    xp->d, xp->w, xp->fggc, XPOS, ypos, (XChar2b *)charBuf[line], charsPerLine);
>-	ypos += height;
>-	if (ypos > HEIGHT - height) {
>-	    /* Wraparound to top of window */
>-	    ypos = XPOS;
>-	    line = startLine;
>-	    startLine = (startLine + 1) % totalLines;
>-	}
>-	line = (line + 1) % totalLines;
>-    }
>-}
>-
>-void DoPolyText(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, line, startLine;
>-
>-    startLine = 0;
>-    line = 0;
>-    for (i = 0; i != reps; i++) {
>-	XDrawText(
>-	    xp->d, xp->w, xp->fggc, XPOS, ypos, &items[line*SEGS], SEGS);
>-	ypos += height;
>-	if (ypos > HEIGHT - height) {
>-	    /* Wraparound to top of window */
>-	    ypos = XPOS;
>-	    line = startLine;
>-	    startLine = (startLine + 1) % totalLines;
>-	}
>-	line = (line + 1) % totalLines;
>-    }
>-}
>-
>-void DoPolyText16(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, line, startLine;
>-
>-    startLine = 0;
>-    line = 0;
>-    for (i = 0; i != reps; i++) {
>-	XDrawText16(
>-	    xp->d, xp->w, xp->fggc, XPOS, ypos, (XTextItem16 *)&items[line*SEGS], SEGS);
>-	ypos += height;
>-	if (ypos > HEIGHT - height) {
>-	    /* Wraparound to top of window */
>-	    ypos = XPOS;
>-	    line = startLine;
>-	    startLine = (startLine + 1) % totalLines;
>-	}
>-	line = (line + 1) % totalLines;
>-    }
>-}
>-
>-void DoImageText(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, line, startLine;
>-
>-    startLine = 0;
>-    line = 0;
>-    for (i = 0; i != reps; i++) {
>-	XDrawImageString(
>-	    xp->d, xp->w, xp->fggc, XPOS, ypos, charBuf[line], charsPerLine);
>-	ypos += height;
>-	if (ypos > HEIGHT - height) {
>-	    /* Wraparound to top of window */
>-	    ypos = XPOS;
>-	    startLine = (startLine + 17) % totalLines;
>-	    line = startLine;
>-	}
>-	line = (line + 1) % totalLines;
>-    }
>-}
>-
>-void DoImageText16(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, line, startLine;
>-
>-    startLine = 0;
>-    line = 0;
>-    for (i = 0; i != reps; i++) {
>-	XDrawImageString16(
>-	    xp->d, xp->w, xp->fggc, XPOS, ypos, (XChar2b *)charBuf[line], charsPerLine);
>-	ypos += height;
>-	if (ypos > HEIGHT - height) {
>-	    /* Wraparound to top of window */
>-	    ypos = XPOS;
>-	    startLine = (startLine + 17) % totalLines;
>-	    line = startLine;
>-	}
>-	line = (line + 1) % totalLines;
>-    }
>-}
>-
>-void ClearTextWin(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XClearWindow(xp->d, xp->w);
>-}
>-
>-void EndText(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    int i;
>-
>-    if(font==NULL)return;
>-    for (i = 0; i != totalLines; i++)
>-	free(charBuf[i]);
>-    free(charBuf);
>-    if (p->special)
>-	free(items);
>-    XFreeFont(xp->d, font);
>-    if (bfont != NULL)
>-	XFreeFont(xp->d, bfont);
>-}
>-
>-void EndText16(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    int i;
>-
>-    if(font==NULL)return;
>-    if (p->special) {
>-	for (i = 0; i < totalLines; i++) {
>-	    free(items[i*SEGS+0].chars);
>-	    free(items[i*SEGS+1].chars);
>-	    free(items[i*SEGS+2].chars);
>-	}
>-	free(items);
>-    } else {
>-	for (i = 0; i < totalLines; i++) {
>-	    free(charBuf[i]);
>-	}
>-	free(charBuf);
>-    }
>-    XFreeFont(xp->d, font);
>-    if(bfont != NULL) {
>-	XFreeFont(xp->d, bfont);
>-    }
>-}
>-
>Index: xc/programs/x11perf/do_traps.c
>===================================================================
>RCS file: xc/programs/x11perf/do_traps.c
>diff -N xc/programs/x11perf/do_traps.c
>--- xc/programs/x11perf/do_traps.c	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,111 +0,0 @@
>-/* $Xorg: do_traps.c,v 1.3 2000/08/17 19:54:10 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-#include "bitmaps.h"
>-
>-#define NUM_POINTS 4   /* 4 points to a trapezoid */
>-static XPoint *points;
>-static GC      pgc;
>-
>-int InitTrapezoids(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, numPoints;
>-    int     rows;
>-    int     x, y;
>-    int     size, skew;
>-    XPoint  *curPoint;
>-
>-    pgc = xp->fggc;
>-
>-    size = p->special;
>-    numPoints = (p->objects) * NUM_POINTS;  
>-    points = (XPoint *)malloc(numPoints * sizeof(XPoint));
>-    curPoint = points;
>-    x = size;
>-    y = 0;
>-    rows = 0;
>-    skew = size;
>-
>-    for (i = 0; i != p->objects; i++, curPoint += NUM_POINTS) {
>-	curPoint[0].x = x - skew;
>-	curPoint[0].y = y;
>-	curPoint[1].x = x - skew + size;
>-	curPoint[1].y = y;
>-	curPoint[2].x = x + skew;
>-	curPoint[2].y = y + size;
>-	curPoint[3].x = x + skew - size;
>-	curPoint[3].y = y + size;
>-
>-	skew--;
>-	if (skew < 0) skew = size;
>-
>-	y += size;
>-	rows++;
>-	if (y + size > HEIGHT || rows == MAXROWS) {
>-	    rows = 0;
>-	    y = 0;
>-	    x += 2 * size;
>-	    if (x + size > WIDTH) {
>-		x = size;
>-	    }
>-	}
>-    }
>-
>-    SetFillStyle(xp, p);
>-    return reps;
>-}
>-
>-void DoTrapezoids(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j;
>-    XPoint  *curPoint;
>-
>-    for (i = 0; i != reps; i++) {
>-        curPoint = points;
>-        for (j = 0; j != p->objects; j++) {
>-            XFillPolygon(xp->d, xp->w, pgc, curPoint, NUM_POINTS, Convex, 
>-			 CoordModeOrigin);
>-            curPoint += NUM_POINTS;
>-	}
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-void EndTrapezoids(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    free(points);
>-}
>-
>Index: xc/programs/x11perf/do_tris.c
>===================================================================
>RCS file: xc/programs/x11perf/do_tris.c
>diff -N xc/programs/x11perf/do_tris.c
>--- xc/programs/x11perf/do_tris.c	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,239 +0,0 @@
>-/* $Xorg: do_tris.c,v 1.3 2000/08/17 19:54:10 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-
>-#undef POLYTRIANGLE_HACK    /* don't use this code */
>-#ifdef POLYTRIANGLE_HACK
>-#include <X11/Xlibint.h>
>-#endif
>-
>-#include "x11perf.h"
>-#include "bitmaps.h"
>-#include <stdio.h>
>-#include <math.h>
>-
>-#define NUM_POINTS 3   /* 3 points to a triangle */
>-static XPoint *points;
>-static GC     pgc;
>-
>-#ifndef PI
>-#define PI  3.14159265357989
>-#endif
>-
>-double Area(p1, p2, p3)
>-    XPoint  p1, p2, p3;
>-{
>-    return
>-      (p1.x*p2.y - p1.x*p3.y + p2.x*p3.y - p2.x*p1.y + p3.x*p1.y - p3.x*p2.y)/2;
>-}
>-
>-double Distance(p1, p2)
>-    XPoint p1, p2;
>-{
>-    return sqrt((float) ((p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y)));
>-}
>-    
>-int InitTriangles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j, numPoints;
>-    int     rows;
>-    int     x, y;
>-    int     size, iradius;
>-    double  phi, phiinc, radius, delta, phi2, area, aarea;
>-    XPoint  *curPoint;
>-
>-    pgc = xp->fggc;
>-
>-    size = p->special;
>-    phi = 0.0;
>-    delta = 2.0 * PI / ((double) NUM_POINTS);
>-    if (xp->version == VERSION1_2) {
>-	radius = ((double) size) * sqrt(3.0)/2.0;
>-	phiinc = delta/10.0;
>-    } else {
>-	/* Version 1.2's radius computation was completely bogus, and resulted
>-	   in triangles with sides about 50% longer than advertised.  However,
>-	   this inadvertently resulted in triangles with areas just a little bit
>-	   smaller than the triangle that covers size^2 pixels, which would
>-	   make the area directly comparable to 10x10 rectangles and 10x10
>-	   trapezoids.  So here's the new computation so -triangleN has the same
>-	   area as -rectN.
>-	 */
>-	radius = ((double) size) * sqrt(sqrt(16.0/27.0));
>-	phiinc = 1.75*PI / ((double) p->objects);
>-    }
>-    iradius = (int) (radius + 0.5);
>-
>-    numPoints = (p->objects) * NUM_POINTS;  
>-    points = (XPoint *)malloc(numPoints * sizeof(XPoint));
>-    curPoint = points;
>-    x = iradius;
>-    y = iradius;
>-    rows = 0;
>-    aarea = 0.0;
>-
>-    for (i = 0; i != p->objects; i++) {
>-	for (j = 0; j != NUM_POINTS; j++) {
>-	    phi2 = phi + ((double) j) * delta;
>-	    curPoint->x = (int) ((double)x + (radius * cos(phi2)) + 0.5);
>-	    curPoint->y = (int) ((double)y + (radius * sin(phi2)) + 0.5);
>-	    curPoint++;
>-	}
>-	area = Area(curPoint[-1], curPoint[-2], curPoint[-3]);
>-	aarea += area;
>-/*	printf("%6.1lf %6.1lf %6.1lf   %6.1lf\n",
>-	    Distance(curPoint[-1], curPoint[-2]),
>-	    Distance(curPoint[-1], curPoint[-3]),
>-	    Distance(curPoint[-2], curPoint[-3]),
>-	    area);
>-*/	
>-	phi += phiinc;
>-	y += 2 * iradius;
>-	rows++;
>-	if (y + iradius > HEIGHT || rows == MAXROWS) {
>-	    rows = 0;
>-	    y = iradius;
>-	    x += 2 * iradius;
>-	    if (x + iradius > WIDTH) {
>-		x = iradius;
>-	    }
>-	}
>-    }
>-/*    printf("Average area = %6.2lf\n", aarea/p->objects); */
>-
>-    SetFillStyle(xp, p);
>-
>-    return reps;
>-}
>-
>-#ifndef POLYTRIANGLE_HACK
>-
>-void DoTriangles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j;
>-    XPoint  *curPoint;
>-
>-    for (i = 0; i != reps; i++) {
>-        curPoint = points;
>-        for (j = 0; j != p->objects; j++) {
>-            XFillPolygon(xp->d, xp->w, pgc, curPoint, NUM_POINTS, Convex, 
>-			 CoordModeOrigin);
>-            curPoint += NUM_POINTS;
>-	}
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-#else
>-void DoTriangles(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i, j;
>-    XPoint  *curPoint;
>-
>-    for (i = 0; i != reps; i++) {
>-        XPolyTriangle (xp->d, xp->w, pgc, points, p->objects, Convex, 
>-			 CoordModeOrigin);
>-        if (pgc == xp->bggc)
>-            pgc = xp->fggc;
>-        else
>-            pgc = xp->bggc;
>-    }
>-}
>-
>-static xReq _dummy_request = {
>-	0, 0, 0
>-};
>-
>-XPolyTriangle(dpy, d, gc, points, n_triangles, shape, mode)
>-register Display *dpy;
>-Drawable d;
>-GC gc;
>-XPoint *points;
>-int n_triangles;
>-int shape;
>-int mode;
>-{
>-    register xFillPolyReq *req;
>-    register long nbytes;
>-    int		max_triangles;
>-    int		n_this_time;
>-    int		*buf, *pts;
>-    int		gcid;
>-    int		last;
>-
>-    max_triangles = (dpy->bufmax - dpy->buffer) / 28;
>-    LockDisplay(dpy);
>-    FlushGC(dpy, gc);
>-    dpy->request += n_triangles;
>-    pts = (int *) points;
>-    gcid = gc->gid;
>-    last = shape | (mode << 8);
>-    while (n_triangles)
>-    {
>-	if ((n_this_time = max_triangles) > n_triangles)
>-	    n_this_time = n_triangles;
>-	n_triangles -= n_this_time;
>-	GetReqExtra(FillPoly, 
>-	    (SIZEOF(xFillPolyReq) + 12) * n_this_time - SIZEOF(xFillPolyReq), req);
>-	--dpy->request;
>-
>-	buf = req;
>-        while (n_this_time--)
>-	{
>-	    buf[0] = X_FillPoly | (7 << 16);
>-	    buf[1] = d;
>-	    buf[2] = gcid;
>-	    buf[3] = last;
>-	    buf[4] = pts[0];
>-	    buf[5] = pts[1];
>-	    buf[6] = pts[2];
>-	    buf += 7;
>-	    pts += 3;
>-	}
>-    }
>-    dpy->last_req = &_dummy_request;
>-    UnlockDisplay(dpy);
>-    SyncHandle();
>-}
>-#endif
>-
>-void EndTriangles(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    free(points);
>-}
>-
>Index: xc/programs/x11perf/do_valgc.c
>===================================================================
>RCS file: xc/programs/x11perf/do_valgc.c
>diff -N xc/programs/x11perf/do_valgc.c
>--- xc/programs/x11perf/do_valgc.c	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,81 +0,0 @@
>-/* $Xorg: do_valgc.c,v 1.3 2000/08/17 19:54:10 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#ifndef VMS
>-#include <X11/Xatom.h>
>-#else
>-#include <decw$include/Xatom.h>
>-#endif
>-#include "x11perf.h"
>-
>-static Window win[2];
>-
>-int InitGC(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    win[0] = XCreateSimpleWindow(
>-	xp->d, xp->w, 10, 10, 10, 10, 1, xp->foreground, xp->background);
>-    win[1] = XCreateSimpleWindow(
>-	xp->d, xp->w, 30, 30, 10, 10, 1, xp->foreground, xp->background);
>-    XMapSubwindows(xp->d, xp->w);
>-    return reps;
>-}
>-
>-void DoChangeGC(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int		i;
>-    XGCValues   gcv;
>-
>-    for (i = 0; i != reps; i++) {
>-        gcv.foreground = xp->foreground;
>-        XChangeGC(xp->d, xp->fggc, GCForeground , &gcv);
>-        XDrawPoint(xp->d, win[0], xp->fggc, 5, 5);       
>-
>-        gcv.foreground = xp->background;
>-        XChangeGC(xp->d, xp->fggc, GCForeground , &gcv);
>-        XDrawPoint(xp->d, win[1], xp->fggc, 5, 5);       
>-
>-        gcv.foreground = xp->background;
>-        XChangeGC(xp->d, xp->fggc, GCForeground , &gcv);
>-        XDrawPoint(xp->d, win[0], xp->fggc, 5, 5);       
>-
>-        gcv.foreground = xp->foreground;
>-        XChangeGC(xp->d, xp->fggc, GCForeground , &gcv);
>-        XDrawPoint(xp->d, win[1], xp->fggc, 5, 5);       
>-    }
>-}
>-
>-void EndGC(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XDestroyWindow(xp->d, win[0]);
>-    XDestroyWindow(xp->d, win[1]);
>-}
>-
>Index: xc/programs/x11perf/do_windows.c
>===================================================================
>RCS file: xc/programs/x11perf/do_windows.c
>diff -N xc/programs/x11perf/do_windows.c
>--- xc/programs/x11perf/do_windows.c	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,289 +0,0 @@
>-/* $Xorg: do_windows.c,v 1.4 2000/08/17 19:54:10 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#include "x11perf.h"
>-
>-static Window *parents;
>-static Window *isolates;
>-static int childrows, childcolumns, childwindows;
>-static int parentrows, parentcolumns, parentwindows;
>-static int parentwidth, parentheight;
>-static Window popup;
>-
>-void ComputeSizes(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    childwindows = p->objects;
>-    childrows = (childwindows + MAXCOLS - 1) / MAXCOLS;
>-    childcolumns = (childrows > 1 ? MAXCOLS : childwindows);
>-
>-    parentwidth = (CHILDSIZE+CHILDSPACE) * childcolumns;
>-    parentheight = (CHILDSIZE+CHILDSPACE) * childrows;
>-}
>-
>-int CreateParents(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i;
>-
>-    ComputeSizes(xp, p);
>-
>-    parentcolumns = WIDTH / parentwidth;
>-    parentrows = HEIGHT / parentheight;
>-    parentwindows = parentcolumns * parentrows; /* Max reps we can fit */
>-
>-    if (parentwindows > reps) {
>-	parentwindows = reps;
>-    }
>-
>-    /* We will do parentwindows sets of childwindows, in order to get better
>-       timing accuracy.  Creating 4 windows at a millisecond apiece or so
>-       is a bit faster than the 60 Hz clock. */
>-    isolates = (Window *)malloc(parentwindows * sizeof(Window));
>-    parents = (Window *)malloc(parentwindows * sizeof(Window));
>-
>-    /*
>-     *  Create isolation windows for the parents, and then the parents
>-     *  themselves.  These isolation windows ensure that parent and children
>-     *  windows created/mapped in DoWins and DoWin2 all see the same local
>-     *  environment...the parent is an only child, and each parent contains
>-     *  the number of children we are trying to get benchmarks on.
>-     */
>-
>-    for (i = 0; i != parentwindows; i++) {
>-	isolates[i] = XCreateSimpleWindow(xp->d, xp->w,
>-	    (i/parentrows)*parentwidth, (i%parentrows)*parentheight,
>-	    parentwidth, parentheight, 0, xp->background, xp->background);
>-	parents[i] = XCreateSimpleWindow(xp->d, isolates[i],
>-	    0, 0, parentwidth, parentheight, 0, xp->background, xp->background);
>-    }
>-
>-    XMapSubwindows(xp->d, xp->w);
>-    return parentwindows;
>-} /* CreateParents */
>-
>-
>-void MapParents(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != parentwindows; i++) {
>-	XMapWindow(xp->d, parents[i]);
>-    }
>-}
>-
>-
>-int InitCreate(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    reps = CreateParents(xp, p, reps);
>-    MapParents(xp, p, reps);
>-    return reps;
>-}
>-
>-void CreateChildGroup(xp, p, parent)
>-    XParms  xp;
>-    Parms   p;
>-    Window  parent;
>-{
>-    int j;
>-
>-    for (j = 0; j != childwindows; j++) {
>-	(void) XCreateSimpleWindow (xp->d, parent,
>-		(CHILDSIZE+CHILDSPACE) * (j/childrows) + CHILDSPACE/2,
>-		(CHILDSIZE+CHILDSPACE) * (j%childrows) + CHILDSPACE/2,
>-		CHILDSIZE, CHILDSIZE, 0, xp->background, xp->foreground);
>-    }
>-
>-    if (p->special)
>-	XMapSubwindows (xp->d, parent);
>-}
>-
>-void CreateChildren(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int     i;
>-
>-    for (i = 0; i != parentwindows; i++) {
>-	CreateChildGroup(xp, p, parents[i]);
>-    } /* end i */
>-}
>-
>-void DestroyChildren(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != parentwindows; i++) {
>-	XDestroySubwindows(xp->d, parents[i]);
>-    }
>-}
>-
>-void EndCreate(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    XDestroySubwindows(xp->d, xp->w);
>-    free(parents);
>-    free(isolates);
>-}
>-
>-
>-int InitMap(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    reps = CreateParents(xp, p, reps);
>-    CreateChildren(xp, p, reps);
>-    return reps;
>-}
>-
>-void UnmapParents(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != parentwindows; i++) {
>-	XUnmapWindow(xp->d, parents[i]);
>-    }
>-}
>-
>-int InitDestroy(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    reps = CreateParents(xp, p, reps);
>-    CreateChildren(xp, p, reps);
>-    MapParents(xp, p, reps);
>-    return reps;
>-}
>-
>-void DestroyParents(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-
>-    for (i = 0; i != parentwindows; i++) {
>-	XDestroyWindow(xp->d, parents[i]);
>-    }
>-}
>-
>-
>-void RenewParents(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-    int i;
>-
>-    for (i = 0; i != parentwindows; i++) {
>-	parents[i] = XCreateSimpleWindow(xp->d, isolates[i],
>-	    0, 0, parentwidth, parentheight, 0, xp->background, xp->background);
>-    }
>-    CreateChildren(xp, p, parentwindows);
>-    MapParents(xp, p, parentwindows);
>-}
>-
>-int InitPopups(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-#ifdef CHILDROOT
>-    XWindowAttributes    xwa;
>-#endif
>-    XSetWindowAttributes xswa;
>-    Window isolate;
>-
>-#ifdef CHILDROOT
>-    ComputeSizes(xp, p);
>-    CreateChildGroup(xp, p, xp->w);
>-
>-    /* Now create simple window to pop up over children */
>-    (void) XGetWindowAttributes(xp->d, xp->w, &xwa);
>-    xswa.override_redirect = True;
>-    popup =  XCreateSimpleWindow (
>-	    xp->d, DefaultRootWindow(xp->d), 
>-	    xwa.x + xwa.border_width, xwa.y + xwa.border_width,
>-	    parentwidth, parentheight,
>-	    0, xp->foreground, xp->foreground);
>-#else   
>-    isolate = XCreateSimpleWindow(
>-	    xp->d, xp->w, 0, 0, WIDTH, HEIGHT,
>-	    0, xp->background, xp->background);
>-
>-    ComputeSizes(xp, p);
>-    CreateChildGroup(xp, p, isolate);
>-    XMapWindow(xp->d, isolate);
>-
>-    /* Now create simple window to pop up over children */
>-    xswa.override_redirect = True;
>-    popup =  XCreateSimpleWindow (
>-	    xp->d, xp->w, 0, 0,
>-	    parentwidth, parentheight,
>-	    0, xp->foreground, xp->foreground);
>-#endif
>-    XChangeWindowAttributes (xp->d, popup, CWOverrideRedirect, &xswa);
>-    return reps;
>-}
>-
>-void DoPopUps(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-    for (i = 0; i != reps; i++) {
>-        XMapWindow(xp->d, popup);
>-	XUnmapWindow(xp->d, popup);
>-    }
>-}
>-
>-void EndPopups(xp, p)
>-    XParms  xp;
>-    Parms p;
>-{
>-    XDestroySubwindows(xp->d, xp->w);
>-#ifdef CHILDROOT
>-    XDestroyWindow(xp->d, popup);
>-#endif
>-}
>-
>Index: xc/programs/x11perf/fillblnk.sh
>===================================================================
>RCS file: xc/programs/x11perf/fillblnk.sh
>diff -N xc/programs/x11perf/fillblnk.sh
>--- xc/programs/x11perf/fillblnk.sh	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,15 +0,0 @@
>-#!/bin/sh
>-echo '#####EOF#####' | cat $2 - $1 |
>-awk -F: '\
>-$1 == "#####EOF#####"	{ filling = 1; currentItem = 1; lastItem = NR; next; }
>-filling != "1"	{ itemOrder[" " $1] = NR; name[NR] = $1; }
>-filling == "1"	{ rate[itemOrder[$2]] = $1; }
>-END	{
>-	for (i = 1; i < lastItem; i++) {
>-		if (rate[i] != "") {
>-			printf ("%s: %s\n", rate[i], name[i]);
>-		} else {
>-			printf (" 0 trep @ 0.0 msec (0.0/sec): %s\n", name[i]);
>-		}
>-	}
>-	}'
>Index: xc/programs/x11perf/perfboth.sh
>===================================================================
>RCS file: xc/programs/x11perf/perfboth.sh
>diff -N xc/programs/x11perf/perfboth.sh
>--- xc/programs/x11perf/perfboth.sh	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,40 +0,0 @@
>-#!/bin/sh
>-awk '
>-/^     1/ && READY == 0 {	printf ("    1   ");
>-		for (i = 2; i < NF; i++)
>-			printf ("          %2d        ", i);
>-		printf ("   Operation\n");
>-		next;
>-	}
>-/^---/	{ 	printf ("--------");
>-		for (i = 2; i <= NF; i++)
>-			printf ("   -----------------");
>-		printf ("\n");
>-		READY=1; next;
>- 	}
>-READY==1 {
>-		base=$1;
>-		printf ("%8.1f", base);
>-		for (i = 2; i < '$1'; i++) {
>-			if (base == 0)
>-				printf ("   %8.1f         ", $i);
>-			else {
>-				rate=$i/base;
>-				if (rate < .1)
>-					printf ("   %8.1f (%6.3f)", $i, rate);
>-				else if (rate < 1000)
>-					printf ("   %8.1f (%6.2f)", $i, rate);
>-				else
>-					printf ("   %8.1f (%6.0f)", $i, rate);
>-			}
>-		}
>-		printf ("   ");
>-		for (; i <= NF; i++)
>-		{
>-			printf ("%s ", $i);
>-		}
>-		printf ("\n");
>-		next;
>-	   }
>-	   { print $0; }
>-'
>Index: xc/programs/x11perf/perfratio.sh
>===================================================================
>RCS file: xc/programs/x11perf/perfratio.sh
>diff -N xc/programs/x11perf/perfratio.sh
>--- xc/programs/x11perf/perfratio.sh	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,40 +0,0 @@
>-#!/bin/sh
>-awk '
>-/^     1/ && READY == 0 {	printf ("     1  ");
>-		for (i = 2; i < NF; i++)
>-			printf ("     %2d ", i);
>-		printf ("   Operation\n");
>-		next;
>-	}
>-/^---/	{ 	printf ("--------");
>-		for (i = 2; i < NF; i++)
>-			printf ("  ------");
>-		printf ("   ---------\n");
>-		READY=1; next;
>- 	}
>-READY==1 {
>-		base=$1;
>-		printf ("%8.1f", base);
>-		for (i = 2; i < '$1'; i++) {
>-			if (base == 0)
>-				printf ("   lots ", $i);
>-			else {
>-				rate=$i/base;
>-				if (rate < .1)
>-					printf ("  %6.3f", rate);
>-				else if (rate < 1000)
>-					printf ("  %6.2f", rate);
>-				else
>-					printf ("  %6.0f", rate);
>-			}
>-		}
>-		printf ("   ");
>-		for (; i <= NF; i++)
>-		{
>-			printf ("%s ", $i);
>-		}
>-		printf ("\n");
>-		next;
>-	   }
>-	   { print $0; }
>-'
>Index: xc/programs/x11perf/x11pcomp.cpp
>===================================================================
>RCS file: xc/programs/x11perf/x11pcomp.cpp
>diff -N xc/programs/x11perf/x11pcomp.cpp
>--- xc/programs/x11perf/x11pcomp.cpp	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,100 +0,0 @@
>-XCOMM! /bin/sh
>-XCOMM Collects multiple outputs of x11perf.  Just feed it a list of files, each
>-XCOMM containing the output from an x11perf run, and this shell will extract the
>-XCOMM object/second information and show it in tabular form.  An 80-column line
>-XCOMM is big enough to compare 4 different servers.
>-XCOMM
>-XCOMM This script normally uses the results from $1 to extract the test label
>-XCOMM descriptions, so you can run x11perf on a subset of the test and then
>-XCOMM compare the results.  But note that x11perffill requires the labels file
>-XCOMM to be a superset of the x11perf results file.  If you run into an ugly
>-XCOMM situation in which none of the servers completes the desired tests 
>-XCOMM (quite possible on non-DEC servers :), you can use -l <filename> as $1 and
>-XCOMM $2 to force x11perfcomp to use the labels stored in file $2.  (You can run
>-XCOMM x11perf with the -labels option to generate such a file.)
>-XCOMM
>-XCOMM Mark Moraes, University of Toronto <moraes@csri.toronto.edu>
>-XCOMM Joel McCormack, DEC Western Research Lab <joel@decwrl.dec.com>
>-XCOMM
>-XCOMM $Xorg: x11pcomp.cpp,v 1.3 2000/08/17 19:54:10 cpqbld Exp $
>-
>-PATH=LIBPATH:.:$PATH
>-export PATH
>-
>-set -e
>-tmp=/tmp/rates.$$
>-trap "rm -rf $tmp" 0 1 2 15
>-mkdir $tmp $tmp/rates
>-ratio=
>-allfiles=
>-XCOMM Include relative rates in output?  Report only relative rates?
>-case $1 in
>--r|-a)
>-	ratio=1
>-	shift;
>-	;;
>--ro)
>-	ratio=2
>-	shift;
>-	;;
>-esac
>-XCOMM Get either the provided label file, or construct one from all the
>-XCOMM files given.
>-case $1 in
>--l)	cp $2 $tmp/labels
>-	shift; shift
>-	;;
>-*)	for file in "$@"; do
>-		awk '$2 == "reps" || $2 == "trep" { print $0; next; }' $file |
>- 		sed 's/^.*: //' |
>- 		sed 's/ /_/g' |
>- 		awk 'NR > 1 	{ printf ("%s %s\n", prev, $0); } \
>-				{ prev = $0; }'
>-	done | tsort 2>/dev/null | sed 's/_/ /g' > $tmp/labels
>-	;;
>-esac
>-XCOMM Go through all files, and create a corresponding rate file for each
>-n=1
>-for i
>-do
>-XCOMM Get lines with average numbers, fill in any tests that may be missing
>-XCOMM then extract the rate field
>-	base=`basename $i`
>-	(echo "     $n  "
>-	 echo '--------'
>-	 awk '$2 == "reps" || $2 == "trep" { \
>-		line = $0; \
>-		next; \
>-	    } \
>-	    NF == 0 && line != "" { \
>-		print line; \
>-		line=""; \
>-		next; \
>-	    } \
>-	 ' $i > $tmp/$n.avg
>-	 fillblnk $tmp/$n.avg $tmp/labels |
>-	 sed 's/( *$[0-9]*$/(\1/'   |
>-	 awk '$2 == "reps" || $2 == "trep" { \
>-	 					n = substr($6,2,length($6)-7); \
>-						printf "%8s\n", n; \
>-    	 				   }'
>-	) > $tmp/rates/$n
>-	echo "$n: $i"
>-	allfiles="$allfiles$tmp/rates/$n "
>-	n=`expr $n + 1`
>-done
>-case x$ratio in
>-x)
>-	ratio=/bin/cat
>-	;;
>-x1)
>-	ratio="perfboth $n"
>-	;;
>-*)
>-	ratio="perfratio $n"
>-	;;
>-esac
>-echo ''
>-(echo Operation; echo '---------'; cat $tmp/labels) |
>-paste $allfiles - | sed 's/	/  /g' | $ratio
>-rm -rf $tmp
>Index: xc/programs/x11perf/x11pcomp.man
>===================================================================
>RCS file: xc/programs/x11perf/x11pcomp.man
>diff -N xc/programs/x11perf/x11pcomp.man
>--- xc/programs/x11perf/x11pcomp.man	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,79 +0,0 @@
>-.\" $Xorg: x11pcomp.man,v 1.4 2001/02/09 02:05:38 xorgcvs Exp $
>-.\" Copyright 1993, 1994, 1998  The Open Group
>-.\" 
>-.\" Permission to use, copy, modify, distribute, and sell this software and its
>-.\" documentation for any purpose is hereby granted without fee, provided that
>-.\" the above copyright notice appear in all copies and that both that
>-.\" copyright notice and this permission notice appear in supporting
>-.\" documentation.
>-.\" 
>-.\" 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 OPEN GROUP 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 of The Open Group shall
>-.\" not be used in advertising or otherwise to promote the sale, use or
>-.\" other dealings in this Software without prior written authorization
>-.\" from The Open Group.
>-.TH X11PERFCOMP 1 "Release 6.4" "X Version 11"
>-.SH NAME
>-x11perfcomp \- X11 server performance comparison program
>-.SH SYNTAX
>-.B x11perfcomp
>-[ \-r | \-ro ] [ \-l label_file ] files
>-.SH DESCRIPTION
>-The
>-.I x11perfcomp
>-program merges the output of several
>-.I x11perf(1)
>-runs into a nice tabular
>-format.  It takes the results in each file, fills in any missing test results if
>-necessary, and for each test shows the objects/second rate of each server.
>-If invoked with the -r or -ro options, it shows the relative performance 
>-of each server to the first server.
>-.PP
>-Normally,
>-.I x11perfcomp
>-uses the first file specified to determine which specific tests it should
>-report on.  Some (non-DEC :) servers may fail to perform
>-all tests.  In this case,
>-.I x11perfcomp
>-automatically substitutes in a rate of 0.0 objects/second. 
>-Since the first file
>-determines which tests to report on, this file must contain a superset of
>-the tests reported in the other files, else 
>-.I x11perfcomp
>-will fail.
>-.PP
>-You can provide an explicit list of tests to report on
>-by using the -l switch to specify a file of labels.  You can create a label
>-file by using the -label option in 
>-.I x11perf.
>-.SH OPTIONS
>-.I x11perfcomp
>-accepts the options listed below:
>-.TP 16
>-.B \-r
>-Specifies that the output should also include relative server
>-performance.
>-.TP 16
>-.B \-ro
>-Specifies that the output should include only relative server performance.
>-.TP 16
>-.B \-l label_file
>-Specifies a label file to use.
>-.SH X DEFAULTS
>-There are no X defaults used by this program.
>-.SH "SEE ALSO"
>-X(1), x11perf(1)
>-.SH AUTHORS
>-Mark Moraes wrote the original scripts to compare servers.
>-.br
>-Joel McCormack just munged them together a bit.
>Index: xc/programs/x11perf/x11perf.c
>===================================================================
>RCS file: xc/programs/x11perf/x11perf.c
>diff -N xc/programs/x11perf/x11perf.c
>--- xc/programs/x11perf/x11perf.c	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,1451 +0,0 @@
>-/* $Xorg: x11perf.c,v 1.6 2001/01/23 17:21:42 pookie Exp $ */
>-/****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-****************************************************************************/
>-
>-#include <stdio.h>
>-#include <ctype.h>
>-#include <signal.h>
>-
>-#ifndef VMS
>-#include <X11/Xatom.h>
>-#include <X11/Xos.h>
>-#else
>-#include <decw$include/Xatom.h>
>-#endif
>-#include "x11perf.h"
>-#include <X11/Xmu/SysUtil.h>
>-
>-#ifdef X_NOT_STDC_ENV
>-#define Time_t long
>-extern Time_t time ();
>-#else
>-#include <time.h>
>-#define Time_t time_t
>-#endif
>-
>-/* Only for working on ``fake'' servers, for hardware that doesn't exist */
>-static Bool     drawToFakeServer = False;
>-static Pixmap   tileToQuery     = None;
>-
>-typedef struct _RopNames { char	*name; int  rop; } RopNameRec, *RopNamePtr;
>-
>-RopNameRec ropNames[] = {
>-	"clear",    	GXclear,	/* 0 */
>-	"and",		GXand,		/* src AND dst */
>-	"andReverse",	GXandReverse,	/* src AND NOT dst */
>-	"copy",		GXcopy,		/* src */
>-	"andInverted",	GXandInverted,	/* NOT src AND dst */
>-	"noop",		GXnoop,		/* dst */
>-	"xor",		GXxor,		/* src XOR dst */
>-	"or",		GXor,		/* src OR dst */
>-	"nor",		GXnor,		/* NOT src AND NOT dst */
>-	"equiv",	GXequiv,	/* NOT src XOR dst */
>-	"invert",	GXinvert,	/* NOT dst */
>-	"orReverse",	GXorReverse,	/* src OR NOT dst */
>-	"copyInverted",	GXcopyInverted,	/* NOT src */
>-	"orInverted",	GXorInverted,	/* NOT src OR dst */
>-	"nand",		GXnand,		/* NOT src OR NOT dst */
>-	"set",		GXset,		/* 1 */
>-};
>-
>-char *(visualClassNames)[] = {
>-    "StaticGray",
>-    "GrayScale",
>-    "StaticColor",
>-    "PseudoColor",
>-    "TrueColor",
>-    "DirectColor"
>-};
>-
>-static Bool     labels		= False;
>-static int      repeat		= 5;
>-static int	seconds		= 5;
>-
>-static Window   status;     /* Status window and GC */
>-static GC       tgc;
>-static int	HSx, HSy;
>-
>-static double syncTime = 0.0;
>-
>-static int saveargc;
>-static char **saveargv;
>-
>-static int  numRops = 1;
>-static int  rops[16] = { GXcopy };
>-static int  numPlanemasks = 1;
>-static unsigned long planemasks[256] = { (unsigned long)~0 };
>-
>-static char *foreground = NULL;
>-static char *background = NULL;
>-static char *ddbackground = NULL;
>-static int clips = 0;
>-
>-static int numSubWindows = 7;
>-static unsigned long subWindows[] = {4, 16, 25, 50, 75, 100, 200, 0};
>-
>-static int  fixedReps = 0;
>-
>-static Bool *doit;
>-
>-static XRectangle ws[] = {  /* Clip rectangles */
>-    {195, 195, 120, 120},
>-    { 45, 145, 120, 120},
>-    {345, 245, 120, 120},
>-    { 45, 275, 120, 120},
>-    {345, 115, 120, 120},
>-    {195, 325, 120, 120}
>-
>-};
>-#define MAXCLIP     (sizeof(ws) / sizeof(ws[0]))
>-static Window clipWindows[MAXCLIP];
>-static Colormap cmap;
>-static int depth = -1;  /* -1 means use default depth */
>-static int vclass = -1; /* -1 means use CopyFromParent */
>-static Visual *visual = CopyFromParent;
>-
>-/* ScreenSaver state */
>-static XParmRec    xparms;
>-static int ssTimeout, ssInterval, ssPreferBlanking, ssAllowExposures;
>-
>-
>-/************************************************
>-*	    time related stuff			*
>-************************************************/
>-
>-#ifdef VMS
>-
>-typedef struct _vms_time {
>-    unsigned long low;
>-    unsigned long high;
>-}vms_time;
>-
>-struct timeval {
>-    long tv_sec;        /* seconds since Jan. 1, 1970 */
>-    long tv_usec;  /* and microseconds */
>-};
>-
>-struct timezone {
>-    int  tz_minuteswest;     /* of Greenwich */
>-    int  tz_dsttime;    /* type of dst correction to apply */
>-};
>-
>-
>-static int firsttime = True;
>-static vms_time basetime;
>-
>-int gettimeofday(tp)
>-    struct timeval *tp;
>-{
>-    vms_time current_time, resultant;
>-    unsigned long mumble, foo;
>-    int status;
>-
>-    if (firsttime) {
>-        sys$gettim(&basetime);
>-        firsttime = False;
>-    }
>-    sys$gettim(&current_time);
>-    resultant.high = current_time.high - basetime.high;
>-    resultant.low = current_time.low - basetime.low;
>-    if (current_time.low < basetime.low) {
>-        resultant.high -= 1;
>-    }
>-    status = lib$ediv( &(10000000), &resultant, &tp->tv_sec, &tp->tv_usec);
>-    tp->tv_usec /= 10;
>-    return 0;
>-}
>-
>-#endif
>-
>-static struct  timeval start;
>-
>-void PrintTime()
>-{
>-    Time_t t;
>-
>-    t = time((Time_t *)NULL);
>-    printf("%s\n", ctime(&t));
>-}
>-
>-void InitTimes ()
>-{
>-    X_GETTIMEOFDAY(&start);
>-}
>-
>-double ElapsedTime(correction)
>-    double correction;
>-{
>-    struct timeval stop;
>-
>-    X_GETTIMEOFDAY(&stop);
>-    if (stop.tv_usec < start.tv_usec) {
>-        stop.tv_usec += 1000000;
>-	stop.tv_sec -= 1;
>-    }
>-    return  (double)(stop.tv_usec - start.tv_usec) +
>-            (1000000.0 * (double)(stop.tv_sec - start.tv_sec)) - correction;
>-}
>-
>-double RoundTo3Digits(d)
>-    double d;
>-{
>-    /* It's kind of silly to print out things like ``193658.4/sec'' so just
>-       junk all but 3 most significant digits. */
>-
>-    double exponent, sign;
>-
>-    exponent = 1.0;
>-    /* the code below won't work if d should happen to be non-positive. */
>-    if (d < 0.0) {
>-	d = -d;
>-	sign = -1.0;
>-    } else
>-	sign = 1.0;
>-    if (d >= 1000.0) {
>-	do {
>-	    exponent *= 10.0;
>-	} while (d/exponent >= 1000.0);
>-	d = (double)((int) (d/exponent + 0.5));
>-	d *= exponent;
>-    } else {
>-	if (d != 0.0) {
>-	    while (d*exponent < 100.0) {
>-	        exponent *= 10.0;
>-	    }
>-	}
>-	d = (double)((int) (d*exponent + 0.5));
>-	d /= exponent;
>-    }
>-    return d * sign;
>-}
>-
>-
>-void ReportTimes(usecs, n, str, average)
>-    double  usecs;
>-    int     n;
>-    char    *str;
>-{
>-    double msecsperobj, objspersec;
>-
>-    if(usecs != 0.0)
>-    {
>-        msecsperobj = usecs / (1000.0 * (double)n);
>-        objspersec = (double) n * 1000000.0 / usecs;
>-
>-        /* Round obj/sec to 3 significant digits.  Leave msec untouched, to
>-	   allow averaging results from several repetitions. */
>-        objspersec =  RoundTo3Digits(objspersec);
>-
>-        if (average) {
>-	    printf("%7d trep @ %8.4f msec (%8.1f/sec): %s\n", 
>-		    n, msecsperobj, objspersec, str);
>-	} else {
>-	    printf("%7d reps @ %8.4f msec (%8.1f/sec): %s\n", 
>-	        n, msecsperobj, objspersec, str);
>-	}
>-    } else {
>-	printf("%6d %sreps @ 0.0 msec (unmeasurably fast): %s\n",
>-	    n, average ? "t" : "", str);
>-    }
>-
>-}
>-
>-
>-
>-/************************************************
>-*		Generic X stuff			*
>-************************************************/
>-
>-static char *program_name;
>-void usage();
>-
>-/*
>- * Get_Display_Name (argc, argv) Look for -display, -d, or host:dpy (obselete)
>- * If found, remove it from command line.  Don't go past a lone -.
>- */
>-char *Get_Display_Name(pargc, argv)
>-    int     *pargc;  /* MODIFIED */
>-    char    **argv; /* MODIFIED */
>-{
>-    int     argc = *pargc;
>-    char    **pargv = argv+1;
>-    char    *displayname = NULL;
>-    int     i;
>-
>-    for (i = 1; i != argc; i++) {
>-	char *arg = argv[i];
>-
>-	if (!strcmp (arg, "-display") || !strcmp (arg, "-d")) {
>-	    if (++i >= argc) usage ();
>-
>-	    displayname = argv[i];
>-	    *pargc -= 2;
>-	    continue;
>-	}
>-	if (!strcmp(arg,"-")) {
>-	    while (i<argc)  *pargv++ = argv[i++];
>-	    break;
>-	}
>-	*pargv++ = arg;
>-    }
>-
>-    *pargv = NULL;
>-    return (displayname);
>-}
>-
>-
>-/*
>- * GetVersion (argc, argv) Look for -v1.2, -v1.3, or -v1.4.
>- * If found remove it from command line.  Don't go past a lone -.
>- */
>-
>-Version GetVersion(pargc, argv)
>-    int     *pargc;  /* MODIFIED */
>-    char    **argv; /* MODIFIED */
>-{
>-    int     argc = *pargc;
>-    char    **pargv = argv+1;
>-    Version version = VERSION1_5;
>-    int     i;
>-    Bool    found = False;
>-
>-    for (i = 1; i != argc; i++) {
>-	char *arg = argv[i];
>-
>-	if (!strcmp (arg, "-v1.2")) {
>-	    version = VERSION1_2;
>-	    *pargc -= 1;
>-	    if (found) {
>-		fprintf(stderr, "Warning: multiple version specifications\n");
>-	    }
>-	    found = True;
>-	    continue;
>-	}
>-	if (!strcmp (arg, "-v1.3")) {
>-	    version = VERSION1_3;
>-	    *pargc -= 1;
>-	    if (found) {
>-		fprintf(stderr, "Warning: multiple version specifications\n");
>-	    }
>-	    found = True;
>-	    continue;
>-	}
>-	if (!strcmp (arg, "-v1.4")) {
>-	    version = VERSION1_4;
>-	    *pargc -= 1;
>-	    if (found) {
>-		fprintf(stderr, "Warning: multiple version specifications\n");
>-	    }
>-	    found = True;
>-	    continue;
>-	}
>-	if (!strcmp(arg,"-")) {
>-	    while (i<argc)  *pargv++ = argv[i++];
>-	    break;
>-	}
>-	*pargv++ = arg;
>-    }
>-
>-    *pargv = NULL;
>-    return (version);
>-}
>-
>-
>-
>-/*
>- * Open_Display: Routine to open a display with correct error handling.
>- */
>-Display *Open_Display(display_name)
>-    char *display_name;
>-{
>-    Display *d;
>-
>-    d = XOpenDisplay(display_name);
>-    if (d == NULL) {
>-	fprintf (stderr, "%s:  unable to open display '%s'\n",
>-		 program_name, XDisplayName (display_name));
>-	exit(1);
>-	/* doesn't return */
>-    }
>-
>-    return(d);
>-}
>-
>-
>-#ifdef SIGNALRETURNSINT
>-int
>-#else
>-void
>-#endif
>-Cleanup(sig)
>-    int sig;
>-{
>-    fflush(stdout);
>-    /* This will screw up if Xlib is in the middle of something */
>-    XSetScreenSaver(xparms.d, ssTimeout, ssInterval, ssPreferBlanking,
>-	ssAllowExposures);
>-    XFlush(xparms.d);
>-    exit(sig);
>-}
>-
>-
>-/************************************************
>-*		Performance stuff		*
>-************************************************/
>-
>-
>-void usage()
>-{
>-    char    **cpp;
>-    int     i = 0;
>-    static char *help_message[] = {
>-"where options include:",
>-"    -display <host:display>   the X server to contact",
>-"    -sync                     do the tests in synchronous mode",
>-"    -pack                     pack rectangles right next to each other",
>-"    -repeat <n>               do tests <n> times (default = 5)",
>-"    -time <s>                 do tests for <s> seconds each (default = 5)",
>-/*
>-"    -draw                     draw after each test -- pmax only",
>-*/
>-"    -all                      do all tests",
>-"    -range <test1>[,<test2>]  like all, but do <test1> to <test2>",
>-"    -labels                   generate test labels for use by fillblnk",
>-"    -fg                       the foreground color to use",
>-"    -bg                       the background color to use",
>-"    -clips <default>          default number of clip windows per test",
>-"    -ddbg                     the background color to use for DoubleDash",
>-"    -rop <rop0 rop1 ...>      use the given rops to draw (default = GXcopy)",
>-"    -pm <pm0 pm1 ...>         use the given planemasks to draw (default = ~0)",
>-"    -depth <depth>            use a visual with <depth> planes per pixel",
>-"    -vclass <class>           the visual class to use (default = root)",
>-"    -reps <n>                 fix the rep count (default = auto scale)",
>-"    -subs <s0 s1 ...>         a list of the number of sub-windows to use",
>-"    -v1.2                     perform only v1.2 tests using old semantics",
>-"    -v1.3                     perform only v1.3 tests using old semantics",
>-"    -su                       request save unders on windows",
>-"    -bs <backing_store_hint>  WhenMapped or Always (default = NotUseful)",
>-NULL};
>-
>-    fflush(stdout);
>-    fprintf(stderr, "usage: %s [-options ...]\n", program_name);
>-    for (cpp = help_message; *cpp; cpp++) {
>-	fprintf(stderr, "%s\n", *cpp);
>-    }
>-    while (test[i].option != NULL) {
>-	if (test[i].versions & xparms.version ) {
>-	    fprintf(stderr, "    %-24s   %s\n",
>-		test[i].option,
>-		test[i].label14 ? test[i].label14 : test[i].label);
>-	}
>-        i++;
>-    }
>-    fprintf(stderr, "\n");
>-    
>-    /* Print out original command line as the above usage message is so long */
>-    for (i = 0; i != saveargc; i++) {
>-	fprintf(stderr, "%s ", saveargv[i]);
>-    }
>-    fprintf(stderr, "\n\n");
>-    exit (1);
>-}
>-
>-void NullProc(xp, p)
>-    XParms  xp;
>-    Parms   p;
>-{
>-}
>-
>-Bool NullInitProc(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int reps;
>-{
>-    return reps;
>-}
>-
>-
>-void HardwareSync(xp)
>-    XParms  xp;
>-{
>-    /*
>-     * Some graphics hardware allows the server to claim it is done,
>-     * while in reality the hardware is busily working away.  So fetch
>-     * a pixel from the drawable that was drawn to, which should be
>-     * enough to make the server wait for the graphics hardware.
>-     */
>-    XImage *image;
>-
>-    image = XGetImage(xp->d, xp->p ? xp->p : xp->w, HSx, HSy, 
>-		      1, 1, ~0, ZPixmap);
>-    if (image) XDestroyImage(image);
>-}
>-
>-void DoHardwareSync(xp, p, reps)
>-    XParms  xp;
>-    Parms   p;
>-    int     reps;
>-{
>-    int i;
>-    
>-    for (i = 0; i != reps; i++) {
>-	HardwareSync(xp);
>-    }
>-}
>-
>-static Test syncTest = {
>-    "syncTime", "Internal test for finding how long HardwareSync takes", NULL,
>-    NullInitProc, DoHardwareSync, NullProc, NullProc, 
>-    V1_2FEATURE, NONROP, 0,
>-    {1}
>-};
>-
>-
>-static Window CreatePerfWindow(xp, x, y, width, height)
>-    XParms  xp;
>-    int     width, height, x, y;
>-{
>-    XSetWindowAttributes xswa;
>-    Window w;
>-/*
>-    Screen *s;
>-    int su;
>-
>-    s = DefaultScreenOfDisplay(xp->d);
>-    su = XDoesBackingStore(s);
>-    printf("Backing store of screen returns %d\n", su);
>-    su = XDoesSaveUnders(s);
>-    printf("Save unders of screen returns %d\n", su);
>-    su = XPlanesOfScreen(s);
>-    printf("Planes of screen returns %d\n", su);
>-*/
>-    xswa.background_pixel = xp->background;
>-    xswa.border_pixel = xp->foreground;
>-    xswa.colormap = cmap;
>-    xswa.override_redirect = True;
>-    xswa.backing_store = xp->backing_store;
>-    xswa.save_under = xp->save_under;
>-    w = XCreateWindow(xp->d, DefaultRootWindow(xp->d), x, y, width, height, 1,
>-        xp->vinfo.depth, CopyFromParent, xp->vinfo.visual,
>-	CWBackPixel | CWBorderPixel | CWColormap | CWOverrideRedirect 
>-	| CWBackingStore | CWSaveUnder, &xswa);
>-    XMapWindow (xp->d, w);
>-    return w;
>-}
>-
>-
>-void CreateClipWindows(xp, clips)
>-    XParms  xp;
>-    int     clips;
>-{
>-    int j;
>-    XWindowAttributes    xwa;
>-
>-    (void) XGetWindowAttributes(xp->d, xp->w, &xwa);
>-    if (clips > MAXCLIP) clips = MAXCLIP;
>-    for (j = 0; j != clips; j++) {
>-	clipWindows[j] = CreatePerfWindow(xp,
>-	    xwa.x + ws[j].x, xwa.y + ws[j].y, ws[j].width, ws[j].height);
>-    }
>-} /* CreateClipWindows */
>-
>-
>-void DestroyClipWindows(xp, clips)
>-    XParms  xp;
>-    int     clips;
>-{
>-    int j;
>-
>-    if (clips > MAXCLIP) clips = MAXCLIP;
>-    for (j = 0; j != clips; j++) {
>-	XDestroyWindow(xp->d, clipWindows[j]);
>-    }
>-} /* DestroyClipWindows */
>-
>-
>-double DoTest(xp, test, reps)
>-    XParms  xp;
>-    Test    *test;
>-    int     reps;
>-{
>-    double  time;
>-    unsigned int ret_width, ret_height;
>-
>-    /* Tell screen-saver to restart counting again.  See comments below for the
>-       XSetScreenSaver call. */
>-    XForceScreenSaver(xp->d, ScreenSaverReset);
>-    HardwareSync (xp); 
>-    InitTimes ();
>-    (*test->proc) (xp, &test->parms, reps);
>-    HardwareSync(xp);
>-
>-    time = ElapsedTime(syncTime);
>-    if (drawToFakeServer)
>-        XQueryBestSize(xp->d, TileShape, tileToQuery,
>-		       32, 32, &ret_width, &ret_height);
>-    (*test->passCleanup) (xp, &test->parms);
>-    return time;
>-}
>-
>-
>-int CalibrateTest(xp, test, seconds, usecperobj)
>-    XParms  xp;
>-    Test    *test;
>-    int     seconds;
>-    double  *usecperobj;
>-{
>-#define goal    2500000.0   /* Try to get up to 2.5 seconds		    */
>-#define enough  2000000.0   /* But settle for 2.0 seconds		    */
>-#define tick      10000.0   /* Assume clock not faster than .01 seconds     */
>-
>-    double  usecs;
>-    int     reps, didreps;  /* Reps desired, reps performed		    */
>-    int     exponent;
>-
>-    /* Attempt to get an idea how long each rep lasts by getting enough
>-       reps to last more tan enough.  Then scale that up to the number of
>-       seconds desired.
>-
>-       If init call to test ever fails, return False and test will be skipped.
>-    */
>-
>-    if (fixedReps != 0) {
>-	return fixedReps;
>-    }
>-    reps = 1;
>-    for (;;) {
>-	XDestroySubwindows(xp->d, xp->w);
>-	XClearWindow(xp->d, xp->w);
>-	didreps = (*test->init) (xp, &test->parms, reps);
>-	if (didreps == 0) {
>-	    return 0;
>-	}
>-	if ( test->clips < clips )
>-	  test->clips = clips ;
>-	/* Create clip windows if requested */
>-	CreateClipWindows(xp, test->clips);
>-	HardwareSync(xp);
>-	InitTimes();
>-	(*test->proc) (xp, &test->parms, reps);
>-	HardwareSync(xp);
>-	usecs = ElapsedTime(syncTime);
>-	(*test->passCleanup) (xp, &test->parms);
>-	(*test->cleanup) (xp, &test->parms);
>-	DestroyClipWindows(xp, test->clips);
>-
>-	if (didreps != reps) {
>-	    /* The test can't do the number of reps as we asked for.  
>-	       Give up */
>-	    *usecperobj = 
>-		usecs / (double)(didreps * test->parms.objects);
>-	    return didreps;
>-	}
>-	/* Did we go long enough? */
>-	if (usecs >= enough) break;
>-
>-	/* Don't let too short a clock make new reps wildly high */
>-	if (usecs <= tick)reps = reps*10;
>-	else{
>-	    /* Try to get up to goal seconds. */
>-	    reps = (int) (goal * (double)reps / usecs) + 1;
>-	}
>-    }
>-
>-    *usecperobj = usecs / (double) (reps * test->parms.objects);
>-    reps = (int) ((double)seconds * 1000000.0 * (double)reps / usecs) + 1;
>-
>-    /* Now round reps up to 1 digit accuracy, so we don't get stupid-looking
>-       numbers of repetitions. */
>-    reps--;
>-    exponent = 1;
>-    while (reps > 9) {
>-	reps /= 10;
>-	exponent *= 10;
>-    }
>-    reps = (reps + 1) * exponent;
>-    return reps;
>-} /* CalibrateTest */
>-
>-void CreatePerfGCs(xp, func, pm)
>-    XParms  xp;
>-    int     func;
>-    unsigned long   pm;
>-{
>-    XGCValues gcvfg, gcvbg, gcvddbg,gcvddfg;
>-    unsigned long	fg, bg, ddbg;
>-
>-    fg = xp->foreground;
>-    bg = xp->background;
>-    ddbg = xp->ddbackground;
>-    gcvfg.graphics_exposures = False;
>-    gcvbg.graphics_exposures = False;
>-    gcvddfg.graphics_exposures = False;
>-    gcvddbg.graphics_exposures = False;
>-    gcvfg.plane_mask = pm;
>-    gcvbg.plane_mask = pm;
>-    gcvddfg.plane_mask = pm;
>-    gcvddbg.plane_mask = pm;
>-    gcvfg.function = func;
>-    gcvbg.function = func;
>-    gcvddfg.function = func;
>-    gcvddbg.function = func;
>-    
>-    if (func == GXxor) {
>-	/* Make test look good visually if possible */
>-	gcvbg.foreground = gcvfg.foreground = bg ^ fg;
>-	gcvbg.background = gcvfg.background = bg;
>-	/* Double Dash GCs (This doesn't make a huge amount of sense) */
>-	gcvddbg.foreground = gcvddfg.foreground = bg ^ fg;
>-	gcvddbg.background = gcvddfg.foreground = bg ^ ddbg;
>-    } else {
>-	gcvfg.foreground = fg;
>-	gcvfg.background = bg;
>-	gcvbg.foreground = bg;
>-	gcvbg.background = fg;
>-	gcvddfg.foreground = fg;
>-	gcvddfg.background = ddbg;
>-	gcvddbg.foreground = ddbg;
>-	gcvddbg.background = fg;
>-    }
>-    xp->fggc = XCreateGC(xp->d, xp->w,
>-	GCForeground | GCBackground | GCGraphicsExposures
>-      | GCFunction | GCPlaneMask, &gcvfg);
>-    xp->bggc = XCreateGC(xp->d, xp->w, 
>-	GCForeground | GCBackground | GCGraphicsExposures
>-      | GCFunction | GCPlaneMask, &gcvbg);
>-    xp->ddfggc = XCreateGC(xp->d, xp->w,
>-	GCForeground | GCBackground | GCGraphicsExposures
>-      | GCFunction | GCPlaneMask, &gcvddfg);
>-    xp->ddbggc = XCreateGC(xp->d, xp->w, 
>-	GCForeground | GCBackground | GCGraphicsExposures
>-      | GCFunction | GCPlaneMask, &gcvddbg);
>-}
>-
>-
>-void DestroyPerfGCs(xp)
>-    XParms(xp);
>-{
>-    XFreeGC(xp->d, xp->fggc);
>-    XFreeGC(xp->d, xp->bggc);
>-    XFreeGC(xp->d, xp->ddfggc);
>-    XFreeGC(xp->d, xp->ddbggc);
>-}
>-
>-unsigned long AllocateColor(display, name, pixel)
>-    Display     *display;
>-    char	*name;
>-    unsigned long pixel;
>-{
>-    XColor      color;
>-
>-    if (name != NULL) {
>-	/* Try to parse color name */
>-	if (XParseColor(display, cmap, name, &color)) {
>-	    if (XAllocColor(display, cmap, &color)) {
>-		pixel = color.pixel;
>-	    } else {
>-		(void) fprintf(stderr,
>-		    "Can't allocate colormap entry for color %s\n", name);
>-	    }
>-	} else {
>-	    if(*name >= '0' && *name <= '9')
>-		pixel = atoi(name);
>-	    else
>-		(void) fprintf(stderr, "Can't parse color name %s\n", name);
>-	}
>-    }
>-    return pixel;
>-} /* AllocateColor */
>-
>-
>-void DisplayStatus(d, message, test, try)
>-    Display *d;
>-    char    *message;
>-    char    *test;
>-{
>-    char    s[500];
>-
>-    XClearWindow(d, status);
>-    sprintf(s, "%d %s %s", try, message, test);
>-    /* We should really look at the height, descent of the font, etc. but
>-       who cares.  This works. */
>-    XDrawString(d, status, tgc, 10, 13, s, strlen(s));
>-}
>-
>-
>-void ProcessTest(xp, test, func, pm, label)
>-    XParms  xp;
>-    Test    *test;
>-    int     func;
>-    unsigned long   pm;
>-    char    *label;
>-{
>-    double  time, totalTime;
>-    int     reps;
>-    int     j;
>-
>-    xp->planemask = pm;
>-    CreatePerfGCs(xp, func, pm);
>-    DisplayStatus(xp->d, "Calibrating", label, 0);
>-    reps = CalibrateTest(xp, test, seconds, &time);
>-    if (reps != 0) {
>-	srand(1);	/* allow reproducible results */
>-	XDestroySubwindows(xp->d, xp->w);
>-	XClearWindow(xp->d, xp->w);
>-	reps = (*test->init) (xp, &test->parms, reps);
>-	/*
>-	 * if using fixedReps then will not have done CalibrateTest so must
>-	 * check result of init for 0 here
>-	 */
>-	if(reps == 0){
>-	    DestroyPerfGCs(xp);
>-	    return;
>-	}
>-	/* Create clip windows if requested */
>-	CreateClipWindows(xp, test->clips);
>-
>-	totalTime = 0.0;
>-	for (j = 0; j != repeat; j++) {
>-	    DisplayStatus(xp->d, "Testing", label, j+1);
>-	    time = DoTest(xp, test, reps);
>-	    totalTime += time;
>-	    ReportTimes (time, reps * test->parms.objects,
>-		    label, False);
>-	}
>-	if (repeat > 1) {
>-	    ReportTimes(totalTime,
>-		repeat * reps * test->parms.objects,
>-		label, True);
>-	}
>-	(*test->cleanup) (xp, &test->parms);
>-	DestroyClipWindows(xp, test->clips);
>-    } else {
>-	/* Test failed to initialize properly */
>-    }
>-    printf ("\n");
>-    fflush(stdout);
>-    DestroyPerfGCs(xp);
>-} /* ProcessTest */
>-
>-#ifndef X_NOT_STDC_ENV
>-#define Strstr strstr
>-#else
>-char *Strstr(s1, s2)
>-    char *s1, *s2;
>-{
>-    int n1, n2;
>-
>-    n1 = strlen(s1);
>-    n2 = strlen(s2);
>-    for ( ; n1 >= n2; s1++, n1--) {
>-	if (!strncmp(s1, s2, n2))
>-	    return s1;
>-    }	
>-    return NULL;
>-}
>-#endif
>-
>-#define LABELP(i) (test[i].label14 && (xparms.version >= VERSION1_4) \
>-		        ? test[i].label14 : test[i].label)
>-
>-main(argc, argv)
>-    int argc;
>-    char **argv;
>-
>-{
>-    int		i, j, n, skip;
>-    int		numTests;       /* Even though the linker knows, we don't. */
>-    char	hostname[100];
>-    char	*displayName;
>-    Bool	foundOne = False;
>-    Bool	synchronous = False;
>-    XGCValues	tgcv;
>-    int		screen;
>-    int		rop, pm;
>-    XVisualInfo *vinfolist, vinfotempl;
>-    unsigned long vmask;
>-
>-    /* Save away argv, argc, for usage to print out */
>-    saveargc = argc;
>-    saveargv = (char **) malloc(argc * sizeof(char *));
>-    for (i = 0; i != argc; i++) {
>-	saveargv[i] = argv[i];
>-    }
>-
>-    xparms.pack = False;
>-    xparms.save_under = False;
>-    xparms.backing_store = NotUseful;
>-
>-    /* Count number of tests */
>-    ForEachTest(numTests);
>-    doit = (Bool *)calloc(numTests, sizeof(Bool));
>-
>-    /* Parse arguments */
>-    program_name = argv[0];
>-    displayName = Get_Display_Name (&argc, argv);
>-    xparms.version = GetVersion(&argc, argv);
>-    for (i = 1; i != argc; i++) {
>-	if (strcmp (argv[i], "-all") == 0) {
>-	    ForEachTest (j)
>-		doit[j] = test[j].versions & xparms.version;
>-	    foundOne = True;
>-	} else if (strcmp (argv[i], "-labels") == 0) {
>-	    labels = True;
>-	} else if (strcmp(argv[i], "-range") == 0) {
>-	    char *cp1;
>-	    char *cp2;
>-	    
>-	    if (argc <= ++i)
>-		usage();
>-	    cp1 = argv[i];
>-	    if (*cp1 == '-')
>-		cp1++;
>-	    for (cp2 = cp1; *cp2 != '\0' && *cp2 != ','; cp2++) {};
>-	    if (*cp2 == ',') {
>-		*cp2++ = '\0';
>-		if (*cp2 == '-')
>-		    cp2++;
>-	    } else {
>-		cp2 = "-";
>-	    }
>-	    ForEachTest (j) {
>-		if (strcmp (cp1, (test[j].option) + 1) == 0 &&
>-		    (test[j].versions & xparms.version)) {
>-		    int k = j;
>-		    do {
>-			doit[k] = test[j].versions & xparms.version;
>-		    } while (!(strcmp(cp2, (test[k].option + 1)) == 0 &&
>-			       (test[k].versions & xparms.version)) &&
>-			     test[++k].option != NULL);
>-		    if (*cp2 != '-' && test[k].option == NULL)
>-			usage();
>-		    break;
>-		}
>-	    }
>-	    if (test[j].option == NULL)
>-		usage();
>-	    foundOne = True;
>-	} else if (strcmp (argv[i], "-sync") == 0) {
>-	    synchronous = True;
>-	} else if (strcmp(argv[i], "-pack") == 0) {
>-	    xparms.pack = True;
>-	} else if (strcmp (argv[i], "-draw") == 0) {
>-	    drawToFakeServer = True;
>-	} else if (strcmp (argv[i], "-repeat") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-		usage ();
>-	    repeat = atoi (argv[i]);
>-	    if (repeat <= 0)
>-	       usage ();
>-	} else if (strcmp (argv[i], "-time") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-		usage ();
>-	    seconds = atoi (argv[i]);
>-	    if (seconds <= 0)
>-	       usage ();
>-	} else if (strcmp(argv[i], "-fg") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-		usage ();
>-	    foreground = argv[i];
>-        } else if (strcmp(argv[i], "-bg") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-		usage ();
>-	    background = argv[i];
>-	    if(ddbackground == NULL)
>-		ddbackground = argv[i];
>-	} else if (strcmp(argv[i], "-clips") == 0 ) {
>-	    i++;
>-	    if (argc <= i)
>-		usage ();
>-	    clips = atoi( argv[i] );
>-	} else if (strcmp(argv[i], "-ddbg") == 0) {
>-	    if (argc <= i)
>-		usage ();
>-	    i++;
>-	    ddbackground = argv[i];
>-	} else if (strcmp(argv[i], "-rop") == 0) {
>-	    skip = GetRops (i+1, argc, argv, rops, &numRops);
>-	    i += skip;
>-	} else if (strcmp(argv[i], "-pm") == 0) {
>-	    skip = GetNumbers (i+1, argc, argv, planemasks, &numPlanemasks);
>-	    i += skip;
>-	} else if (strcmp(argv[i], "-xor") == 0) {
>-	    numRops = 1;
>-	    rops[0] = GXxor;
>-	} else if (strcmp (argv[i], "-both") == 0) {
>-	    numRops = 2;
>-	    rops[0] = GXcopy;
>-	    rops[1] = GXxor;
>-	} else if (strcmp(argv[i], "-reps") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-		usage ();
>-	    fixedReps = atoi (argv[i]);
>-	    if (fixedReps <= 0)
>-		usage ();
>-        } else if (strcmp(argv[i], "-depth") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-                usage ();
>-            depth = atoi(argv[i]);
>-            if (depth <= 0)
>-		usage ();
>-        } else if (strcmp(argv[i], "-vclass") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-                usage ();
>-	    for (j = StaticGray; j <= DirectColor; j++) {
>-		if (strcmp(argv[i], visualClassNames[j]) == 0) {
>-		    vclass = j;
>-		    break;
>-		}
>-	    }
>-            if (vclass < 0)
>-		usage ();
>-	} else if (strcmp(argv[i], "-subs") == 0) {
>-	    skip = GetNumbers (i+1, argc, argv, subWindows, &numSubWindows);
>-	    i += skip;
>-	} else if (strcmp(argv[i], "-v1.2") == 0) {
>-	    xparms.version = VERSION1_2;
>-	} else if (strcmp(argv[i], "-v1.3") == 0) {
>-	    xparms.version = VERSION1_3;
>-	} else if (strcmp(argv[i], "-su") == 0) {
>-	    xparms.save_under = True;
>-	} else if (strcmp(argv[i], "-bs") == 0) {
>-	    i++;
>-	    if (argc <= i)
>-		usage ();
>-	    if (strcmp(argv[i], "WhenMapped") == 0) {
>-	      xparms.backing_store = WhenMapped;
>-	    } else if (strcmp(argv[i], "Always") == 0) {
>-	      xparms.backing_store = Always;
>-	    } else usage ();
>-	} else {
>-	    int len,found;
>-	    ForEachTest (j) {
>-		if (strcmp (argv[i], test[j].option) == 0 &&
>-		    (test[j].versions & xparms.version)) {
>-		    doit[j] = True;
>-		    goto LegalOption;
>-		}
>-	    }
>-	    found = False;
>-	    len = strlen(argv[i]);
>-	    if(len>=3)
>-	    ForEachTest (j) {
>-		if (Strstr (test[j].option, argv[i]+1) != 0) {
>-		    fprintf(stderr,"	-> %s	%s\n", test[j].option, LABELP(j));
>-		    doit[j] = found = True;
>-		}
>-	    }
>-	    if(!found)
>-	    ForEachTest (j) {
>-		if (Strstr (LABELP(j), argv[i]+1) != 0) {
>-		    fprintf(stderr,"	-> %s	%s\n", test[j].option, LABELP(j));
>-		    doit[j] = found = True;
>-		}
>-	    }
>-	    if(!found)
>-		usage ();
>-	LegalOption: 
>-		foundOne = True;
>-	}
>-    }
>-
>-    if (labels) {
>-	/* Just print out list of tests for use with .sh programs that
>-	   assemble data from different x11perf runs into a nice format */
>-	ForEachTest (i) {
>-	    int child;
>-	    if (doit[i]) {
>-		switch (test[i].testType) {
>-		    case NONROP:
>-			printf ("%s\n", LABELP(i));
>-			break;
>-    
>-		    case ROP:
>-			/* Run it through all specified rops and planemasks */
>-			for (rop = 0; rop < numRops; rop++) {
>-			    for (pm = 0; pm < numPlanemasks; pm++) {
>-				if (planemasks[pm] == ~0) {
>-				    if (rops[rop] == GXcopy) {
>-					printf ("%s\n", LABELP(i));
>-				    } else {
>-					printf ("(%s) %s\n",
>-					    ropNames[rops[rop]].name,
>-					    LABELP(i));
>-				    }
>-				} else {
>-				    printf ("(%s 0x%x) %s\n",
>-					    ropNames[rops[rop]].name,
>-					    planemasks[pm],
>-					    LABELP(i));
>-				}
>-			    } /* for pm */
>-			} /* for rop */
>-			break;
>-		    
>-		    case PLANEMASK:
>-			/* Run it through all specified planemasks */
>-			for (pm = 0; pm < numPlanemasks; pm++) {
>-			    if (planemasks[pm] == ~0) {
>-				printf ("%s\n", LABELP(i));
>-			    } else {
>-				printf ("(0x%x) %s\n",
>-					planemasks[pm],
>-					LABELP(i));
>-			    }
>-			} /* for pm */
>-			break;
>-		    
>-		    case WINDOW:
>-			for (child = 0; child != numSubWindows; child++) {
>-			    printf ("%s (%d kids)\n",
>-				LABELP(i), subWindows[child]);
>-			}
>-			break;
>-		} /* switch */
>-	    }
>-	}
>-	exit(0);
>-    }
>-
>-    if (!foundOne)
>-	usage ();
>-    xparms.d = Open_Display (displayName);
>-    screen = DefaultScreen(xparms.d);
>-
>-    /* get visual info of default visual */
>-    vmask = VisualIDMask | VisualScreenMask;
>-    vinfotempl.visualid = XVisualIDFromVisual(XDefaultVisual(xparms.d, screen));
>-    vinfotempl.screen = screen;
>-    vinfolist = XGetVisualInfo(xparms.d, vmask, &vinfotempl, &n);
>-    if (!vinfolist || n != 1) {
>-	fprintf (stderr, "%s: can't get visual info of default visual\n",
>-	    program_name);
>-	exit(1);
>-    }
>-
>-    if (depth == -1 && vclass == -1) {
>-	/* use the default visual and colormap */
>-	xparms.vinfo = *vinfolist;
>-	cmap = XDefaultColormap(xparms.d, screen);
>-    } else {
>-	/* find the specified visual */
>-	int errorDepth = vinfolist[0].depth;
>-	int errorClass = vinfolist[0].class;
>-
>-	vmask = VisualScreenMask;
>-	vinfotempl.screen = screen;
>-	if (depth >= 0) {
>-	    vinfotempl.depth = depth;
>-	    vmask |= VisualDepthMask;
>-	    errorDepth = depth;
>-	}
>-	if (vclass >= 0) {
>-	    vinfotempl.class = vclass;
>-	    vmask |= VisualClassMask;
>-	    errorClass = vclass;
>-	}
>-	vinfolist = XGetVisualInfo(xparms.d, vmask, &vinfotempl, &n);
>-	if (!vinfolist) {
>-	    fprintf (stderr,
>-		"%s: can't find a visual of depth %d and class %s\n",
>-		program_name, errorDepth, visualClassNames[errorClass]);
>-	    exit(1);
>-	}
>-	xparms.vinfo = *vinfolist;  /* use the first one in list */
>-	if (xparms.vinfo.visualid ==
>-	    XVisualIDFromVisual(XDefaultVisual(xparms.d, screen))) {
>-	    /* matched visual is same as default visual */
>-	    cmap = XDefaultColormap(xparms.d, screen);
>-	} else {
>-	    cmap = XCreateColormap(xparms.d, DefaultRootWindow(xparms.d),
>-		xparms.vinfo.visual, AllocNone);
>-	    /* since this is not default cmap, must force color allocation */
>-	    if (!foreground) foreground = "Black";
>-	    if (!background) background = "White";
>-	    XInstallColormap(xparms.d, cmap);
>-	}
>-    }
>-
>-    printf("x11perf - X11 performance program, version %s\n",
>-	   xparms.version & VERSION1_5 ? "1.5" :
>-	   xparms.version & VERSION1_4 ? "1.4" :
>-	   xparms.version & VERSION1_3 ? "1.3" :
>-	   "1.2"
>-	   );
>-    XmuGetHostname(hostname, 100);
>-    printf ("%s server version %d on %s\nfrom %s\n",
>-	    ServerVendor (xparms.d), VendorRelease (xparms.d),
>-	    DisplayString (xparms.d), hostname);
>-    PrintTime ();
>-
>-    /* Force screen out of screen-saver mode, grab current data, and set
>-       time to blank to 8 hours.  We should just be able to turn the screen-
>-       saver off, but this causes problems on some servers.  We also reset
>-       the screen-saver timer each test, as 8 hours is about the maximum time
>-       we can use, and that isn't long enough for some X terminals using a
>-       serial protocol to finish all the tests.  As long as the tests run to 
>-       completion, the old screen-saver values are restored. */
>-    XForceScreenSaver(xparms.d, ScreenSaverReset);
>-    XGetScreenSaver(xparms.d, &ssTimeout, &ssInterval, &ssPreferBlanking,
>-	&ssAllowExposures);
>-    (void) signal(SIGINT, Cleanup); /* ^C */
>-#ifdef SIGQUIT
>-    (void) signal(SIGQUIT, Cleanup);
>-#endif
>-    (void) signal(SIGTERM, Cleanup);
>-#ifdef SIGHUP
>-    (void) signal(SIGHUP, Cleanup);
>-#endif
>-    XSetScreenSaver(xparms.d, 8 * 3600, ssInterval, ssPreferBlanking, 
>-	ssAllowExposures);
>-
>-    if (drawToFakeServer) {
>-        tileToQuery =
>-	    XCreatePixmap(xparms.d, DefaultRootWindow (xparms.d), 32, 32, 1);
>-    }
>-
>-
>-    xparms.foreground =
>-	AllocateColor(xparms.d, foreground, BlackPixel(xparms.d, screen));
>-    xparms.background =
>-	AllocateColor(xparms.d, background, WhitePixel(xparms.d, screen));
>-    xparms.ddbackground =
>-	AllocateColor(xparms.d, ddbackground, WhitePixel(xparms.d, screen));
>-    xparms.w = CreatePerfWindow(&xparms, 2, 2, WIDTH, HEIGHT);
>-    HSx = WIDTH-1;
>-    if (3 + WIDTH > DisplayWidth(xparms.d, screen))
>-	HSx = DisplayWidth(xparms.d, screen) - 4;
>-    HSy = HEIGHT-1;
>-    if (3 + HEIGHT > DisplayHeight(xparms.d, screen))
>-	HSy = DisplayHeight(xparms.d, screen) - 4;
>-    status = CreatePerfWindow(&xparms, 2, HEIGHT+5, WIDTH, 20);
>-    tgcv.foreground = 
>-	AllocateColor(xparms.d, "black", BlackPixel(xparms.d, screen));
>-    tgcv.background = 
>-	AllocateColor(xparms.d, "white", WhitePixel(xparms.d, screen));
>-    tgc = XCreateGC(xparms.d, status, GCForeground | GCBackground, &tgcv);
>-   
>-    xparms.p = (Pixmap)0;
>-
>-    if (synchronous)
>-	XSynchronize (xparms.d, True);
>-
>-    /* Get mouse pointer out of the way of the performance window.  On
>-       software cursor machines it will slow graphics performance.  On
>-       all current MIT-derived servers it will slow window 
>-       creation/configuration performance. */
>-    XWarpPointer(xparms.d, None, status, 0, 0, 0, 0, WIDTH+10, 20+10);
>-
>-    /* Figure out how long to call HardwareSync, so we can adjust for that
>-       in our total elapsed time */
>-    (void) CalibrateTest(&xparms, &syncTest, 1, &syncTime);
>-    printf("Sync time adjustment is %6.4f msecs.\n\n", syncTime/1000);
>-
>-    ForEachTest (i) {
>-	int child;
>-	char label[200];
>-
>-	if (doit[i] && (test[i].versions & xparms.version)) {
>-	    switch (test[i].testType) {
>-	        case NONROP:
>-		    /* Simplest...just run it once */
>-		    strcpy (label, LABELP(i));
>-		    ProcessTest(&xparms, &test[i], GXcopy, ~0L, label);
>-		    break;
>-
>-		case ROP:
>-		    /* Run it through all specified rops and planemasks */
>-		    for (rop = 0; rop < numRops; rop++) {
>-			for (pm = 0; pm < numPlanemasks; pm++) {
>-			    if (planemasks[pm] == ~0) {
>-				if (rops[rop] == GXcopy) {
>-				    sprintf (label, "%s", LABELP(i));
>-				} else {
>-				    sprintf (label, "(%s) %s",
>-					ropNames[rops[rop]].name,
>-					LABELP(i));
>-				}
>-			    } else {
>-				sprintf (label, "(%s 0x%x) %s",
>-					ropNames[rops[rop]].name,
>-					planemasks[pm],
>-					LABELP(i));
>-			    }
>-			    ProcessTest(&xparms, &test[i], rops[rop],
>-				        planemasks[pm], label);
>-			} /* for pm */
>-		    } /* for rop */
>-		    break;
>-		
>-		case PLANEMASK:
>-		    /* Run it through all specified planemasks */
>-		    for (pm = 0; pm < numPlanemasks; pm++) {
>-			if (planemasks[pm] == ~0) {
>-			    sprintf (label, "%s", LABELP(i));
>-			} else {
>-			    sprintf (label, "(0x%x) %s",
>-				    planemasks[pm],
>-				    LABELP(i));
>-			}
>-			ProcessTest(&xparms, &test[i], GXcopy,
>-				    planemasks[pm], label);
>-		    } /* for pm */
>-		    break;
>-		
>-		case WINDOW:
>-		    /* Loop through number of children array */
>-		    for (child = 0; child != numSubWindows; child++) {
>-			test[i].parms.objects = subWindows[child];
>-			sprintf(label, "%s (%d kids)",
>-			    LABELP(i), test[i].parms.objects);
>-			ProcessTest(&xparms, &test[i], GXcopy, ~0L, label);
>-		    }
>-		    break;
>-	    } /* switch */
>-	} /* if doit */
>-    } /* ForEachTest */
>-
>-    XFreeGC(xparms.d, tgc);
>-    XDestroyWindow(xparms.d, xparms.w);
>-    XFree(vinfolist);
>-    if (drawToFakeServer)
>-    	XFreePixmap(xparms.d, tileToQuery);
>-    /* Restore ScreenSaver to original state. */
>-    XSetScreenSaver(xparms.d, ssTimeout, ssInterval, ssPreferBlanking,
>-	ssAllowExposures);
>-    XCloseDisplay(xparms.d);
>-    free(saveargv);
>-    free(doit);
>-}
>-
>-int
>-GetWords (argi, argc, argv, wordsp, nump)
>-    int     argi;
>-    int     argc;
>-    char    **argv;
>-    char    **wordsp;
>-    int     *nump;
>-{
>-    int	    count;
>-
>-    if (argc <= argi)
>-	usage();
>-    count = 0;
>-    while (argv[argi] && *(argv[argi]) != '-') {
>-	*wordsp++ = argv[argi];
>-	++argi;
>-	count++;
>-    }
>-    *nump = count;
>-    return count;
>-}
>-
>-static long
>-atox (s)
>-    char    *s;
>-{
>-    long   v, c;
>-
>-    v = 0;
>-    while (*s) {
>-	if ('0' <= *s && *s <= '9')
>-	    c = *s - '0';
>-	else if ('a' <= *s && *s <= 'f')
>-	    c = *s - 'a' + 10;
>-	else if ('A' <= *s && *s <= 'F')
>-	    c = *s - 'A' + 10;
>-	v = v * 16 + c;
>-	s++;
>-    }
>-    return v;
>-}
>-
>-int GetNumbers (argi, argc, argv, intsp, nump)
>-    int     argi;
>-    int     argc;
>-    char    **argv;
>-    unsigned long    *intsp;
>-    int     *nump;
>-{
>-    char    *words[256];
>-    int	    count;
>-    int	    i;
>-    int	    flip;
>-
>-    count = GetWords (argi, argc, argv, words, nump);
>-    for (i = 0; i < count; i++) {
>-	flip = 0;
>-	if (!strncmp (words[i], "~", 1)) {
>-	    words[i]++;
>-	    flip = ~0;
>-	}
>-	if (!strncmp (words[i], "0x", 2))
>-	    intsp[i] = atox(words[i] + 2) ^ flip;
>-	else
>-	    intsp[i] = atoi (words[i]) ^ flip;
>-    }
>-    return count;
>-}
>-
>-GetRops (argi, argc, argv, ropsp, nump)
>-    int     argi;
>-    int     argc;
>-    char    **argv;
>-    int     *ropsp;
>-    int     *nump;
>-{
>-    char    *words[256];
>-    int	    count;
>-    int	    i;
>-    int	    rop;
>-
>-    count = GetWords (argi, argc, argv, words, nump);
>-    for (i = 0; i < count; i++) {
>-	if (!strncmp (words[i], "GX", 2))
>-	    words[i] += 2;
>-	if (!strcmp (words[i], "all")) {
>-	    for (i = 0; i < 16; i++)
>-		ropsp[i] = ropNames[i].rop;
>-	    *nump = 16;
>-	    break;
>-	}
>-	for (rop = 0; rop < 16; rop++) {
>-	    if (!strcmp (words[i], ropNames[rop].name)) {
>-		ropsp[i] = ropNames[rop].rop;
>-		break;
>-	    }
>-	}
>-	if (rop == 16) {
>-	    usage ();
>-	    fprintf (stderr, "unknown rop name %s\n", words[i]);
>-	}
>-    }
>-    return count;
>-}
>Index: xc/programs/x11perf/x11perf.h
>===================================================================
>RCS file: xc/programs/x11perf/x11perf.h
>diff -N xc/programs/x11perf/x11perf.h
>--- xc/programs/x11perf/x11perf.h	28 May 2002 01:48:45 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,173 +0,0 @@
>-/* $Xorg: x11perf.h,v 1.3 2000/08/17 19:54:10 cpqbld Exp $ */
>-/*****************************************************************************
>-Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
>-
>-                        All Rights Reserved
>-
>-Permission to use, copy, modify, and distribute this software and its 
>-documentation for any purpose and without fee is hereby granted, 
>-provided that the above copyright notice appear in all copies and that
>-both that copyright notice and this permission notice appear in 
>-supporting documentation, and that the name of Digital not be
>-used in advertising or publicity pertaining to distribution of the
>-software without specific, written prior permission.  
>-
>-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>-SOFTWARE.
>-
>-******************************************************************************/
>-
>-#ifndef VMS
>-#include <X11/Xlib.h>
>-#include <X11/Xutil.h>
>-#else
>-#include <decw$include/Xlib.h>
>-#include <decw$include/Xutil.h>
>-#endif
>-#if defined(XlibSpecificationRelease) && XlibSpecificationRelease >= 5
>-#include <X11/Xfuncs.h>
>-#endif
>-#ifndef NULL
>-#define NULL 0
>-#endif
>-
>-#define POLY	     1000       /* # (small) items in poly calls	*/
>-#define MAXROWS	       40       /* Max rows of items in poly calls      */
>-#define MAXCOLS	       25       /* Max columns of items			*/
>-
>-#define WIDTH         600	/* Size of large window to work within  */
>-#define HEIGHT        600
>-
>-#define CHILDSIZE       8       /* Size of children on windowing tests  */
>-#define CHILDSPACE      4       /* Space between children		*/
>-
>-#define BigTile	((char *)2)		/* Big tile/stipple */
>-#define OddTile	((char *)1)		/* Odd sized tile/stipple */
>-
>-typedef Bool (*InitProc)    (/* XParms xp; Parms p */);
>-typedef void (*Proc)	    (/* XParms xp; Parms p */);
>-
>-extern void NullProc	    (/* XParms xp; Parms p */);
>-extern Bool NullInitProc    (/* XParms xp; Parms p */);
>-
>-typedef unsigned char Version;
>-
>-#define VERSION1_2  ((Version)(1 << 0))
>-#define VERSION1_3  ((Version)(1 << 1))
>-#define VERSION1_4  ((Version)(1 << 2))
>-#define VERSION1_5  ((Version)(1 << 3))
>-#define V1_2ONLY VERSION1_2
>-#define V1_2FEATURE	(VERSION1_2 | VERSION1_3 | VERSION1_4 | VERSION1_5)
>-#define V1_3FEATURE	(VERSION1_3 | VERSION1_4 | VERSION1_5)
>-#define V1_4FEATURE	(VERSION1_4 | VERSION1_5)
>-#define V1_5FEATURE     (VERSION1_5)
>-
>-typedef struct _Parms {
>-    /* Required fields */
>-    int  objects;       /* Number of objects to process in one X call	    */
>-
>-    /* Optional fields.  (Wouldn't object-oriented programming be nice ?)   */
>-    int  special;       /* Usually size of objects to paint		    */
>-    char *font, *bfont;
>-    int  fillStyle;     /* Solid, transparent stipple, opaque stipple, tile */
>-} ParmRec, *Parms;
>-
>-typedef struct _XParms {
>-    Display	    *d;
>-    Window	    w;
>-    Pixmap          p;
>-    GC		    fggc;
>-    GC		    bggc;
>-    GC		    ddfggc;
>-    GC		    ddbggc;
>-    unsigned long   foreground;
>-    unsigned long   background;
>-    unsigned long   ddbackground;
>-    XVisualInfo     vinfo;
>-    Bool	    pack;
>-    Version	    version;
>-    Bool	    save_under;
>-    int		    backing_store;
>-    unsigned long   planemask;
>-} XParmRec, *XParms;
>-
>-typedef enum {
>-    WINDOW,     /* Windowing test, rop, planemask have no affect	*/
>-    ROP,	/* Graphics test, rop, planemask has some affect	*/
>-    PLANEMASK,  /* Graphics test, rop no affect, planemask some affect  */
>-    NONROP      /* Graphics or overhead test, rop has no affect		*/
>-} TestType;
>-
>-typedef struct _Test {
>-    char	*option;    /* Name to use in prompt line		    */
>-    char	*label;     /* Fuller description of test		    */
>-    char	*label14;   /* Labels that are different in Version 1.4     */
>-    InitProc    init;       /* Initialization procedure			    */
>-    Proc	proc;       /* Timed benchmark procedure		    */
>-    Proc	passCleanup;/* Cleanup between repetitions of same test     */
>-    Proc	cleanup;    /* Cleanup after test			    */
>-    Version     versions;   /* Test in 1.2 only, 1.3 only, or both	    */
>-    TestType    testType;   /* Windowing, graphics rop, graphics non-rop    */
>-    int		clips;      /* Number of obscuring windows to force clipping*/
>-    ParmRec     parms;      /* Parameters passed to test procedures	    */
>-} Test;
>-
>-extern Test test[];
>-
>-#define ForEachTest(x) for (x = 0; test[x].option != NULL; x++)
>-
>-
>-/*****************************************************************************
>-
>-About x11perf:
>-
>-Many graphics benchmarks assume that the graphics device is used to display the
>-output of a single fancy graphics application, and that the user gets his work
>-done on some other device, like a terminal.  Such benchmarks usually measure
>-drawing speed for lines, polygons, text, etc.
>-
>-Since workstations are not used as standalone graphics engines, but as
>-super-terminals, x11perf measures window management performance as well as
>-traditional graphics performace.  x11perf includes benchmarks for the time it
>-takes to create and map windows (as when you start up an application); to map a
>-pre-existing set of windows onto the screen (as when you deiconify an
>-application or pop up a menu); and to rearrange windows (as when you slosh
>-windows to and fro trying to find the one you want).
>-
>-x11perf also measures graphics performance for operations not normally used in
>-standalone graphics displays, but are nonetheless used frequently by X
>-applications.  Such operations include CopyPlane (used by the PostScript
>-previewer), scrolling (used in text windows), and various stipples and tiles
>-(used for CAD and half-toning, respectively).
>-
>-x11perf DOES NOT attempt to whittle down measurements to a single ``HeXStones''
>-number.  We consider such numbers to be uninformative at best and misleading at
>-worst.  x11perf should be used to analyze particular strengths and weaknesses
>-of servers, and is most useful when used by a server writer who wants to
>-analyze and improve a server.
>-
>-For repeatable results, x11perf should be run using a local connection on a
>-freshly-started server.  The default configuration runs each test 5 times, in
>-order to see if each trial takes approximately the same amount of time.
>-Strange glitches should be examined; if non-repeatable I chalk them up to
>-daemons and network traffic.  Each trial is run for 5 seconds, in order to
>-reduce random time differences.  The number of objects processed per second is
>-displayed to 3 significant digits, but you'll be lucky on most UNIX system if
>-the numbers are actually consistent to 2 digits.
>-
>-The current program is mostly the responsibility of Joel McCormack.  It is
>-based upon the x11perf developed by Phil Karlton, Susan Angebranndt, and Chris
>-Kent, who wanted to assess performance differences between various servers.
>-Mary Walker, Todd Newman, and I added several tests in order to write and tune
>-the pmax (DECStation 3100) servers.  For a general release to the world, I've
>-basically rewritten x11perf to ease making comparisons between widely varying
>-machines, to cover most important X functionality (the notable exception being
>-wide lines), and to exercise graphics operations in as many different
>-orientations and alignments as possible.
>-
>-******************************************************************************/
>Index: xc/programs/x11perf/x11perf.man
>===================================================================
>RCS file: xc/programs/x11perf/x11perf.man
>diff -N xc/programs/x11perf/x11perf.man
>--- xc/programs/x11perf/x11perf.man	28 May 2002 01:48:46 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,1015 +0,0 @@
>-.\" $Xorg: x11perf.man,v 1.4 2001/02/09 02:05:38 xorgcvs Exp $
>-.\" Copyright 1988, 1989 Digital Equipment Corporation.
>-.\" Copyright 1989, 1994, 1998  The Open Group
>-.\" 
>-.\" Permission to use, copy, modify, distribute, and sell this software and its
>-.\" documentation for any purpose is hereby granted without fee, provided that
>-.\" the above copyright notice appear in all copies and that both that
>-.\" copyright notice and this permission notice appear in supporting
>-.\" documentation.
>-.\" 
>-.\" 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 OPEN GROUP 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 of The Open Group shall
>-.\" not be used in advertising or otherwise to promote the sale, use or
>-.\" other dealings in this Software without prior written authorization
>-.\" from The Open Group.
>-.TH X11PERF 1 "Release 6.4" "X Version 11"
>-.SH NAME
>-x11perf \- X11 server performance test program
>-.SH SYNTAX
>-.B x11perf
>-[ \-option ... ]
>-.SH DESCRIPTION
>-The
>-.I x11perf
>-program runs one or more performance tests and reports how fast an X server can
>-execute the tests.
>-.PP
>-Many graphics benchmarks assume that the graphics device is used to display the
>-output of a single fancy graphics application, and that the user gets his work
>-done on some other device, like a terminal.  Such benchmarks usually measure
>-drawing speed for lines, polygons, text, etc.
>-.PP
>-Since workstations are not used as standalone graphics engines, but as
>-super-terminals, 
>-.I x11perf 
>-measures window management performance as well as
>-traditional graphics performace.  
>-.I x11perf 
>-includes benchmarks for the time it
>-takes to create and map windows (as when you start up an application); to map a
>-pre-existing set of windows onto the screen (as when you deiconify an
>-application or pop up a menu); and to rearrange windows (as when you slosh
>-windows to and fro trying to find the one you want).
>-.PP
>-.I x11perf 
>-also measures graphics performance for operations not normally used in
>-standalone graphics displays, but are nonetheless used frequently by X
>-applications.  Such operations include CopyPlane (used to map bitmaps into
>-pixels), scrolling (used in text windows), and various stipples and tiles
>-(used for CAD and color half-toning, respectively).
>-.PP
>-.I x11perf 
>-should be used to analyze particular strengths and weaknesses
>-of servers, and is most useful to a server writer who wants to
>-analyze and improve a server.
>-.I x11perf
>-is meant to comprehensively exercise just about every X11 operation you can
>-perform; it does not purport to be a representative sample of the
>-operations that X11 applications actually use.
>-While it can be used as a benchmark, it was written and is intended as
>-a performance testing tool.
>-.PP
>-As such,
>-.I x11perf 
>-DOES NOT whittle down measurements to a single ``HeXStones''
>-or ``MeXops'' number.  We consider such numbers to be uninformative 
>-at best and misleading at worst.  
>-Some servers which are very fast for certain applications can be
>-very slow for others.
>-No single number or small set of numbers are sufficient to
>-characterize how an X implementation will perform on all applications.
>-However, by knowledge of your favorite application, you
>-may be able to use the numbers
>-.I x11perf
>-reports to predict its performance on a given X implementation.
>-.PP
>-That said, you might also want to look at
>-.I x11perfcomp(1),
>-a program to compare the outputs of different 
>-.I x11perf
>-runs.  You provide a list of files containing results from
>-.I x11perf,
>-and it lays them out in a nice tabular format.
>-.PP
>-For repeatable results, 
>-.I x11perf 
>-should be run using a local connection on a
>-freshly-started server.  The default configuration runs each test 5 times, in
>-order to see if each trial takes approximately the same amount of time.
>-Strange glitches should be examined; if non-repeatable one might
>-chalk them up to
>-daemons and network traffic.  Each trial is run for 5 seconds, in order to
>-reduce random time differences.  The number of objects processed per second is
>-displayed to 3 significant digits, but you'll be lucky on most UNIX system if
>-the numbers are actually consistent to 2 digits.
>-.I x11perf
>-moves the cursor out of the test window; you should be careful not
>-to bump the mouse and move it back into the window.
>-(A prize to people who correctly explain why!!).
>-.PP
>-Before running a test,
>-.I x11perf
>-determines what the round trip time to the server is, and factors this out of
>-the final timing reported.  It ensures that the server has actually performed
>-the work requested by fetching a pixel back from the test window, which means
>-that servers talking to graphics accelerators can't claim that they are done,
>-while in the meantime the accelerator is painting madly.
>-.PP
>-By default 
>-.I x11perf
>-automatically calibrates the number of repetitions of each test,
>-so that each should take approximately the same length of time to run across
>-servers of widely differing speeds.  However, since each test must be run to
>-completion at least once, some slow servers may take a very long time,
>-particularly on the window moving and resizing tests, and on the arc drawing
>-tests.
>-.PP
>-All timing reports are for the smallest object involved.  For example, the line
>-tests use a PolyLine request to paint several lines at once, but report how
>-many lines per second the server can paint, not how many PolyLine requests per
>-second.  Text tests paint a line of characters, but report on the number of
>-characters per second.  Some window tests map, unmap, or move a single parent
>-window, but report on how many children windows per second the server can map,
>-unmap, or move.
>-.PP
>-The current program is mostly the responsibility of Joel McCormack.  It is
>-based upon the x11perf developed by Phil Karlton, Susan Angebranndt, Chris
>-Kent, Mary Walker, and Todd Newman, who wanted to assess performance differences between various servers.
>-Several tests were added  in order to write and tune
>-the PMAX (DECStation 3100) servers.  
>-For a general release to the world, 
>-.I x11perf 
>-was rewritten to ease making comparisons between widely varying
>-machines, to cover most important (and unimportant) X functionality,
>-and to exercise graphics operations in as many different
>-orientations and alignments as possible.
>-.SH OPTIONS
>-.I x11perf 
>-is solely Xlib based, and
>-accepts the options listed below:
>-.TP 14
>-.B \-display host:dpy
>-Specifies which display to use.
>-.TP 14
>-.B \-sync
>-Runs the tests in synchronous mode.
>-Normally only useful for debugging 
>-.I x11perf .
>-.TP 14
>-.B \-pack
>-Runs rectangle tests so that they pack rectangles right next to each other.
>-This makes it easy to debug server code for stipples and tiles...if the
>-pattern looks ugly, you've got alignment problems.
>-.TP 14
>-.B \-repeat \fI<n>\fP
>-Repeats each test 
>-.I n
>-times (by default each test is run 5 times).
>-.TP 14
>-.B \-time \fI<s>\fP
>-Specifies how long in seconds each test should be run (default 5 seconds).
>-.TP 14
>-.B \-all
>-Runs all tests.  This may take a while.
>-.TP 14
>-.B \-range \fI<test1>\fP[,\fI<test2>\fP]
>-Runs all the tests starting from the specified name \fItest1\fP until
>-the name \fItest2\fP, including both the specified tests. The testnames
>-should be one of the options starting from -dot. (eg) -range line100
>-will peform the tests from the 100 pixel line test, and go on till the
>-last test, -range line100,dline10 will do the tests from line100 to
>-dline10.
>-.TP 14
>-.B \-labels
>-Generates just the descriptive labels for each test specified.  See
>-.I x11perfcomp
>-for more details.
>-.TP 14
>-.B \-fg \fIcolor-or-pixel\fP
>-Specifies the foreground color or pixel value to use.
>-.TP 14
>-.B \-bg \fIcolor-or-pixel\fP
>-Specifies the background color or pixel value to use.
>-.TP 14
>-.B \-clips \fIdefault\fP
>-Default number of clip windows.
>-.TP 14
>-.B \-ddbg \fIcolor-or-pixel\fP
>-Specifies the color or pixel value to use for drawing
>-the odd segments of a DoubleDashed line or arc.
>-This will default to the bg color.
>-.TP 14
>-.B \-rop <rop0 rop1 ...>
>-Use specified raster ops (default is GXcopy).
>-This option only affects graphics
>-benchmarks in which the graphics function is actually used.
>-.TP 14
>-.B \-pm <pm0 pm1 ...>
>-Use specified planemasks (default is ~0).
>-This option only affects graphics
>-benchmarks in which the planemask is actually used.
>-.TP 14
>-.B \-depth <depth>
>-Use a visual with <depth> planes per pixel (default is the default
>-visual).
>-.TP 14
>-.B \-vclass <vclass>
>-Use a visual with of class <vclass>.  <vclass> can be StaticGray, GrayScale,
>-StaticColor, PseudoColor, TrueColor, or DirectColor.  (default is the default
>-visual).
>-.TP 14
>-.B \-reps <n>
>-Specify the repetion count (Default is number that takes aprox. 5 seconds)
>-.TP 14
>-.B \-subs <s0 s1 ...>
>-Specify the number of sub windows to use in the Window tests.
>-Default is  4, 16, 25, 50, 75, 100 and 200.
>-.TP 14
>-.B \-v1.2
>-Perform only x11perf Version 1.2 tests using Version 1.2 semantics.
>-.TP 14
>-.B \-v1.3
>-Perform only x11perf Version 1.3 tests using Version 1.3 semantics.
>-.TP 14
>-.B \-su
>-Set the save_under window attribute to True on all windows created by x11perf.
>-Default is False.
>-.TP 14
>-.B \-bs <backing_store_hint>
>-Set the backing_store window attribute to the given value on all windows 
>-created by x11perf. <backing_store_hint> can be WhenMapped or 
>-Always.  Default is NotUseful.
>-.TP 14
>-.B \-dot
>-Dot.
>-.TP 14
>-.B \-rect1
>-1x1 solid-filled rectangle.
>-.TP 14
>-.B \-rect10
>-10x10 solid-filled rectangle.
>-.TP 14
>-.B \-rect100
>-100x100 solid-filled rectangle.
>-.TP 14
>-.B \-rect500
>-500x500 solid-filled rectangle.
>-.TP 14
>-.B \-srect1
>-1x1 transparent stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-srect10
>-10x10 transparent stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-srect100
>-100x100 transparent stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-srect500
>-500x500 transparent stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-osrect1
>-1x1 opaque stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-osrect10
>-10x10 opaque stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-osrect100
>-100x100 opaque stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-osrect500
>-500x500 opaque stippled rectangle, 8x8 stipple pattern.
>-.TP 14
>-.B \-tilerect1
>-1x1 tiled rectangle, 4x4 tile pattern.
>-.TP 14
>-.B \-tilerect10
>-10x10 tiled rectangle, 4x4 tile pattern.
>-.TP 14
>-.B \-tilerect100
>-100x100 tiled rectangle, 4x4 tile pattern.
>-.TP 14
>-.B \-tilerect500
>-500x500 tiled rectangle, 4x4 tile pattern.
>-.TP 14
>-.B \-oddsrect1
>-1x1 transparent stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddsrect10
>-10x10 transparent stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddsrect100
>-100x100 transparent stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddsrect500
>-500x500 transparent stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddosrect1
>-1x1 opaque stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddosrect10
>-10x10 opaque stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddosrect100
>-100x100 opaque stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddosrect500
>-500x500 opaque stippled rectangle, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddtilerect1
>-1x1 tiled rectangle, 17x15 tile pattern.
>-.TP 14
>-.B \-oddtilerect10
>-10x10 tiled rectangle, 17x15 tile pattern.
>-.TP 14
>-.B \-oddtilerect100
>-100x100 tiled rectangle, 17x15 tile pattern.
>-.TP 14
>-.B \-oddtilerect500
>-500x500 tiled rectangle, 17x15 tile pattern.
>-.TP 14
>-.B \-bigsrect1
>-1x1 stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigsrect10
>-10x10 stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigsrect100
>-100x100 stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigsrect500
>-500x500 stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigosrect1
>-1x1 opaque stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigosrect10
>-10x10 opaque stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigosrect100
>-100x100 opaque stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigosrect500
>-500x500 opaque stippled rectangle, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigtilerect1
>-1x1 tiled rectangle, 161x145 tile pattern.
>-.TP 14
>-.B \-bigtilerect10
>-10x10 tiled rectangle, 161x145 tile pattern.
>-.TP 14
>-.B \-bigtilerect100
>-100x100 tiled rectangle, 161x145 tile pattern.
>-.TP 14
>-.B \-bigtilerect500
>-500x500 tiled rectangle, 161x145 tile pattern.
>-.TP 14
>-.B \-eschertilerect1
>-1x1 tiled rectangle, 215x208 tile pattern.
>-.TP 14
>-.B \-eschertilerect10
>-10x10 tiled rectangle, 215x208 tile pattern.
>-.TP 14
>-.B \-eschertilerect100
>-100x100 tiled rectangle, 215x208 tile pattern.
>-.TP 14
>-.B \-eschertilerect500
>-500x500 tiled rectangle, 215x208 tile pattern.
>-.TP 14
>-.B \-seg1
>-1-pixel thin line segment.
>-.TP 14
>-.B \-seg10
>-10-pixel thin line segment.
>-.TP 14
>-.B \-seg100
>-100-pixel thin line segment.
>-.TP 14
>-.B \-seg500
>-500-pixel thin line segment.
>-.TP 14
>-.B \-seg100c1
>-100-pixel thin line segment (1 obscuring rectangle).
>-.TP 14
>-.B \-seg100c2
>-100-pixel thin line segment (2 obscuring rectangles).
>-.TP 14
>-.B \-seg100c3
>-100-pixel thin line segment (3 obscuring rectangles).
>-.TP 14
>-.B \-dseg10
>-10-pixel thin dashed segment (3 on, 2 off).
>-.TP 14
>-.B \-dseg100
>-100-pixel thin dashed segment (3 on, 2 off).
>-.TP 14
>-.B \-ddseg100
>-100-pixel thin double-dashed segment (3 fg, 2 bg).
>-.TP 14
>-.B \-hseg10
>-10-pixel thin horizontal line segment.
>-.TP 14
>-.B \-hseg100
>-100-pixel thin horizontal line segment.
>-.TP 14
>-.B \-hseg500
>-500-pixel thin horizontal line segment.
>-.TP 14
>-.B \-vseg10
>-10-pixel thin vertical line segment.
>-.TP 14
>-.B \-vseg100
>-100-pixel thin vertical line segment.
>-.TP 14
>-.B \-vseg500
>-500-pixel thin vertical line segment.
>-.TP 14
>-.B \-whseg10
>-10-pixel wide horizontal line segment.
>-.TP 14
>-.B \-whseg100
>-100-pixel wide horizontal line segment.
>-.TP 14
>-.B \-whseg500
>-500-pixel wide horizontal line segment.
>-.TP 14
>-.B \-wvseg10
>-10-pixel wide vertical line segment.
>-.TP 14
>-.B \-wvseg100
>-100-pixel wide vertical line segment.
>-.TP 14
>-.B \-wvseg500
>-500-pixel wide vertical line segment.
>-.TP 14
>-.B \-line1
>-1-pixel thin (width 0) line.
>-.TP 14
>-.B \-line10
>-10-pixel thin line.
>-.TP 14
>-.B \-line100
>-100-pixel thin line.
>-.TP 14
>-.B \-line500
>-500-pixel thin line.
>-.TP 14
>-.B \-dline10
>-10-pixel thin dashed line (3 on, 2 off).
>-.TP 14
>-.B \-dline100
>-100-pixel thin dashed line (3 on, 2 off).
>-.TP 14
>-.B \-ddline100
>-100-pixel thin double-dashed line (3 fg, 2 bg).
>-.TP 14
>-.B \-wline10
>-10-pixel line, line width 1.
>-.TP 14
>-.B \-wline100
>-100-pixel line, line width 10.
>-.TP 14
>-.B \-wline500
>-500-pixel line, line width 50.
>-.TP 14
>-.B \-wdline100
>-100-pixel dashed line, line width 10 (30 on, 20 off).
>-.TP 14
>-.B \-wddline100
>-100-pixel double-dashed line, line width 10 (30 fg, 20 bg).
>-.TP 14
>-.B \-orect10
>-10x10 thin rectangle outline.
>-.TP 14
>-.B \-orect100
>-100-pixel thin vertical line segment.
>-.TP 14
>-.B \-orect500
>-500-pixel thin vertical line segment.
>-.TP 14
>-.B \-worect10
>-10x10 wide rectangle outline.
>-.TP 14
>-.B \-worect100
>-100-pixel wide vertical line segment.
>-.TP 14
>-.B \-worect500
>-500-pixel wide vertical line segment.
>-.TP 14
>-.B \-circle1
>-1-pixel diameter thin (line width 0) circle.
>-.TP 14
>-.B \-circle10
>-10-pixel diameter thin circle.
>-.TP 14
>-.B \-circle100
>-100-pixel diameter thin circle.
>-.TP 14
>-.B \-circle500
>-500-pixel diameter thin circle.
>-.TP 14
>-.B \-dcircle100
>-100-pixel diameter thin dashed circle (3 on, 2 off).
>-.TP 14
>-.B \-ddcircle100
>-100-pixel diameter thin double-dashed circle (3 fg, 2 bg).
>-.TP 14
>-.B \-wcircle10
>-10-pixel diameter circle, line width 1.
>-.TP 14
>-.B \-wcircle100
>-100-pixel diameter circle, line width 10.
>-.TP 14
>-.B \-wcircle500
>-500-pixel diameter circle, line width 50.
>-.TP 14
>-.B \-wdcircle100
>-100-pixel diameter dashed circle, line width 10 (30 on, 20 off).
>-.TP 14
>-.B \-wddcircle100
>-100-pixel diameter double-dashed circle, line width 10 (30 fg, 20 bg).
>-.TP 14
>-.B \-pcircle10
>-10-pixel diameter thin partial circle,
>-orientation and arc angle evenly distributed.
>-.TP 14
>-.B \-pcircle100
>-100-pixel diameter thin partial circle.
>-.TP 14
>-.B \-wpcircle10
>-10-pixel diameter wide partial circle.
>-.TP 14
>-.B \-wpcircle100
>-100-pixel diameter wide partial circle.
>-.TP 14
>-.B \-fcircle1
>-1-pixel diameter filled circle.
>-.TP 14
>-.B \-fcircle10
>-10-pixel diameter filled circle.
>-.TP 14
>-.B \-fcircle100
>-100-pixel diameter filled circle.
>-.TP 14
>-.B \-fcircle500
>-500-pixel diameter filled circle.
>-.TP 14
>-.B \-fcpcircle10
>-10-pixel diameter partial filled circle, chord fill,
>-orientation and arc angle evenly distributed.
>-.TP 14
>-.B \-fcpcircle100
>-100-pixel diameter partial filled circle, chord fill.
>-.TP 14
>-.B \-fspcircle10
>-10-pixel diameter partial filled circle, pie slice fill,
>-orientation and arc angle evenly distributed.
>-.TP 14
>-.B \-fspcircle100
>-100-pixel diameter partial filled circle, pie slice fill.
>-.TP 14
>-.B \-ellipse10
>-10-pixel diameter thin (line width 0) ellipse, major and
>-minor axis sizes evenly distributed.
>-.TP 14
>-.B \-ellipse100
>-100-pixel diameter thin ellipse.
>-.TP 14
>-.B \-ellipse500
>-500-pixel diameter thin ellipse.
>-.TP 14
>-.B \-dellipse100
>-100-pixel diameter thin dashed ellipse (3 on, 2 off).
>-.TP 14
>-.B \-ddellipse100
>-100-pixel diameter thin double-dashed ellipse (3 fg, 2 bg).
>-.TP 14
>-.B \-wellipse10
>-10-pixel diameter ellipse, line width 1.
>-.TP 14
>-.B \-wellipse100
>-100-pixel diameter ellipse, line width 10.
>-.TP 14
>-.B \-wellipse500
>-500-pixel diameter ellipse, line width 50.
>-.TP 14
>-.B \-wdellipse100
>-100-pixel diameter dashed ellipse, line width 10 (30 on, 20 off).
>-.TP 14
>-.B \-wddellipse100
>-100-pixel diameter double-dashed ellipse, line width 10 (30 fg, 20 bg).
>-.TP 14
>-.B \-pellipse10
>-10-pixel diameter thin partial ellipse.
>-.TP 14
>-.B \-pellipse100
>-100-pixel diameter thin partial ellipse.
>-.TP 14
>-.B \-wpellipse10
>-10-pixel diameter wide partial ellipse.
>-.TP 14
>-.B \-wpellipse100
>-100-pixel diameter wide partial ellipse.
>-.TP 14
>-.B \-fellipse10
>-10-pixel diameter filled ellipse.
>-.TP 14
>-.B \-fellipse100
>-100-pixel diameter filled ellipse.
>-.TP 14
>-.B \-fellipse500
>-500-pixel diameter filled ellipse.
>-.TP 14
>-.B \-fcpellipse10
>-10-pixel diameter partial filled ellipse, chord fill.
>-.TP 14
>-.B \-fcpellipse100
>-100-pixel diameter partial filled ellipse, chord fill.
>-.TP 14
>-.B \-fspellipse10
>-10-pixel diameter partial filled ellipse, pie slice fill.
>-.TP 14
>-.B \-fspellipse100
>-100-pixel diameter partial filled ellipse, pie slice fill.
>-.TP 14
>-.B \-triangle1
>-Fill 1-pixel/side triangle.
>-.TP 14
>-.B \-triangle10
>-Fill 10-pixel/side triangle.
>-.TP 14
>-.B \-triangle100
>-Fill 100-pixel/side triangle.
>-.TP 14
>-.B \-trap1
>-Fill 1x1 trapezoid.
>-.TP 14
>-.B \-trap10
>-Fill 10x10 trapezoid.
>-.TP 14
>-.B \-trap100
>-Fill 100x100 trapezoid.
>-.TP 14
>-.B \-trap300
>-Fill 300x300 trapezoid.
>-.TP 14
>-.B \-strap1
>-Fill 1x1 transparent stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-strap10
>-Fill 10x10 transparent stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-strap100
>-Fill 100x100 transparent stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-strap300
>-Fill 300x300 transparent stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-ostrap1
>-Fill 10x10 opaque stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-ostrap10
>-Fill 10x10 opaque stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-ostrap100
>-Fill 100x100 opaque stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-ostrap300
>-Fill 300x300 opaque stippled trapezoid, 8x8 stipple pattern.
>-.TP 14
>-.B \-tiletrap1
>-Fill 10x10 tiled trapezoid, 4x4 tile pattern.
>-.TP 14
>-.B \-tiletrap10
>-Fill 10x10 tiled trapezoid, 4x4 tile pattern.
>-.TP 14
>-.B \-tiletrap100
>-Fill 100x100 tiled trapezoid, 4x4 tile pattern.
>-.TP 14
>-.B \-tiletrap300
>-Fill 300x300 tiled trapezoid, 4x4 tile pattern.
>-.TP 14
>-.B \-oddstrap1
>-Fill 1x1 transparent stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddstrap10
>-Fill 10x10 transparent stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddstrap100
>-Fill 100x100 transparent stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddstrap300
>-Fill 300x300 transparent stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddostrap1
>-Fill 10x10 opaque stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddostrap10
>-Fill 10x10 opaque stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddostrap100
>-Fill 100x100 opaque stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddostrap300
>-Fill 300x300 opaque stippled trapezoid, 17x15 stipple pattern.
>-.TP 14
>-.B \-oddtiletrap1
>-Fill 10x10 tiled trapezoid, 17x15 tile pattern.
>-.TP 14
>-.B \-oddtiletrap10
>-Fill 10x10 tiled trapezoid, 17x15 tile pattern.
>-.TP 14
>-.B \-oddtiletrap100
>-Fill 100x100 tiled trapezoid, 17x15 tile pattern.
>-.TP 14
>-.B \-oddtiletrap300
>-Fill 300x300 tiled trapezoid, 17x15 tile pattern.
>-.TP 14
>-.B \-bigstrap1
>-Fill 1x1 transparent stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigstrap10
>-Fill 10x10 transparent stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigstrap100
>-Fill 100x100 transparent stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigstrap300
>-Fill 300x300 transparent stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigostrap1
>-Fill 10x10 opaque stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigostrap10
>-Fill 10x10 opaque stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigostrap100
>-Fill 100x100 opaque stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigostrap300
>-Fill 300x300 opaque stippled trapezoid, 161x145 stipple pattern.
>-.TP 14
>-.B \-bigtiletrap1
>-Fill 10x10 tiled trapezoid, 161x145 tile pattern.
>-.TP 14
>-.B \-bigtiletrap10
>-Fill 10x10 tiled trapezoid, 161x145 tile pattern.
>-.TP 14
>-.B \-bigtiletrap100
>-Fill 100x100 tiled trapezoid, 161x145 tile pattern.
>-.TP 14
>-.B \-bigtiletrap300
>-Fill 300x300 tiled trapezoid, 161x145 tile pattern.
>-.TP 14
>-.B \-eschertiletrap1
>-Fill 1x1 tiled trapezoid, 216x208 tile pattern.
>-.TP 14
>-.B \-eschertiletrap10
>-Fill 10x10 tiled trapezoid, 216x208 tile pattern.
>-.TP 14
>-.B \-eschertiletrap100
>-Fill 100x100 tiled trapezoid, 216x208 tile pattern.
>-.TP 14
>-.B \-eschertiletrap300
>-Fill 300x300 tiled trapezoid, 216x208 tile pattern.
>-.TP 14
>-.B \-complex10
>-Fill 10-pixel/side complex polygon.
>-.TP 14
>-.B \-complex100
>-Fill 100-pixel/side complex polygon.
>-.TP 14
>-.B \-64poly10convex
>-Fill 10x10 convex 64-gon.
>-.TP 14
>-.B \-64poly100convex
>-Fill 100x100 convex 64-gon.
>-.TP 14
>-.B \-64poly10complex
>-Fill 10x10 complex 64-gon.
>-.TP 14
>-.B \-64poly100complex
>-Fill 100x100 complex 64-gon.
>-.TP 14
>-.B \-ftext
>-Character in 80-char line (6x13).
>-.TP 14
>-.B \-f8text
>-Character in 70-char line (8x13).
>-.TP 14
>-.B \-f9text
>-Character in 60-char line (9x15).
>-.TP 14
>-.B \-f14text16
>-2-byte character in 40-char line (k14).
>-.TP 14
>-.B \-tr10text
>-Character in 80-char line (Times-Roman 10).
>-.TP 14
>-.B \-tr24text
>-Character in 30-char line (Times-Roman 24).
>-.TP 14
>-.B \-polytext
>-Character in 20/40/20 line (6x13, Times-Roman 10, 6x13).
>-.TP 14
>-.B \-polytext16
>-2-byte character in 7/14/7 line (k14, k24).
>-.TP 14
>-.B \-fitext
>-Character in 80-char image line (6x13).
>-.TP 14
>-.B \-f8itext
>-Character in 70-char image line (8x13).
>-.TP 14
>-.B \-f9itext
>-Character in 60-char image line (9x15).
>-.TP 14
>-.B \-f14itext16
>-2-byte character in 40-char image line (k14).
>-.TP 14
>-.B \-f24itext16
>-2-byte character in 23-char image line (k24).
>-.TP 14
>-.B \-tr10itext
>-Character in 80-char image line (Times-Roman 10).
>-.TP 14
>-.B \-tr24itext
>-Character in 30-char image line (Times-Roman 24).
>-.TP 14
>-.B \-scroll10
>-Scroll 10x10 pixels vertically.
>-.TP 14
>-.B \-scroll100
>-Scroll 100x100 pixels vertically.
>-.TP 14
>-.B \-scroll500
>-Scroll 500x500 pixels vertically.
>-.TP 14
>-.B \-copywinwin10
>-Copy 10x10 square from window to window.
>-.TP 14
>-.B \-copywinwin100
>-Copy 100x100 square from window to window.
>-.TP 14
>-.B \-copywinwin500
>-Copy 500x500 square from window to window.
>-.TP 14
>-.B \-copypixwin10
>-Copy 10x10 square from pixmap to window.
>-.TP 14
>-.B \-copypixwin100
>-Copy 100x100 square from pixmap to window.
>-.TP 14
>-.B \-copypixwin500
>-Copy 500x500 square from pixmap to window.
>-.TP 14
>-.B \-copywinpix10
>-Copy 10x10 square from window to pixmap.
>-.TP 14
>-.B \-copywinpix100
>-Copy 100x100 square from window to pixmap.
>-.TP 14
>-.B \-copywinpix500
>-Copy 500x500 square from window to pixmap.
>-.TP 14
>-.B \-copypixpix10
>-Copy 10x10 square from pixmap to pixmap.
>-.TP 14
>-.B \-copypixpix100
>-Copy 100x100 square from pixmap to pixmap.
>-.TP 14
>-.B \-copypixpix500
>-Copy 500x500 square from pixmap to pixmap.
>-.TP 14
>-.B \-copyplane10
>-Copy 10x10 1-bit deep plane.
>-.TP 14
>-.B \-copyplane100
>-Copy 100x100 1-bit deep plane.
>-.TP 14
>-.B \-copyplane500
>-Copy 500x500 1-bit deep plane.
>-.TP 14
>-.B \-putimage10
>-PutImage 10x10 square.
>-.TP 14
>-.B \-putimage100
>-PutImage 100x100 square.
>-.TP 14
>-.B \-putimage500
>-PutImage 500x500 square.
>-.TP 14
>-.B \-putimagexy10
>-PutImage XY format 10x10 square.
>-.TP 14
>-.B \-putimagexy100
>-PutImage XY format 100x100 square.
>-.TP 14
>-.B \-putimagexy500
>-PutImage XY format 500x500 square.
>-.TP 14
>-.B \-shmput10
>-PutImage 10x10 square, MIT shared memory extension.
>-.TP 14
>-.B \-shmput100
>-PutImage 100x100 square, MIT shared memory extension.
>-.TP 14
>-.B \-shmput500
>-PutImage 500x500 square, MIT shared memory extension.
>-.TP 14
>-.B \-shmputxy10
>-PutImage XY format 10x10 square, MIT shared memory extension.
>-.TP 14
>-.B \-shmputxy100
>-PutImage XY format 100x100 square, MIT shared memory extension.
>-.TP 14
>-.B \-shmputxy500
>-PutImage XY format 500x500 square, MIT shared memory extension.
>-.TP 14
>-.B \-getimage10
>-GetImage 10x10 square.
>-.TP 14
>-.B \-getimage100
>-GetImage 100x100 square.
>-.TP 14
>-.B \-getimage500
>-GetImage 500x500 square.
>-.TP 14
>-.B \-getimagexy10
>-GetImage XY format 10x10 square.
>-.TP 14
>-.B \-getimagexy100
>-GetImage XY format 100x100 square.
>-.TP 14
>-.B \-getimagexy500
>-GetImage XY format 500x500 square.
>-.TP 14
>-.B \-noop
>-X protocol NoOperation.
>-.TP 14
>-.B \-atom
>-GetAtomName.
>-.TP 14
>-.B \-pointer
>-QueryPointer.
>-.TP 14
>-.B \-prop
>-GetProperty.
>-.TP 14
>-.B \-gc
>-Change graphics context.
>-.TP 14
>-.B \-create
>-Create child window and map using MapSubwindows.
>-.TP 14
>-.B \-ucreate
>-Create unmapped window.
>-.TP 14
>-.B \-map
>-Map child window via MapWindow on parent.
>-.TP 14
>-.B \-unmap
>-Unmap child window via UnmapWindow on parent.
>-.TP 14
>-.B \-destroy
>-Destroy child window via DestroyWindow parent.
>-.TP 14
>-.B \-popup
>-Hide/expose window via Map/Unmap popup window.
>-.TP 14
>-.B \-move
>-Move window.
>-.TP 14
>-.B \-umove
>-Moved unmapped window.
>-.TP 14
>-.B \-movetree
>-Move window via MoveWindow on parent.
>-.TP 14
>-.B \-resize
>-Resize window.
>-.TP 14
>-.B \-uresize
>-Resize unmapped window.
>-.TP 14
>-.B \-circulate
>-Circulate lowest window to top.
>-.TP 14
>-.B \-ucirculate
>-Circulate unmapped window to top.
>-.SH X DEFAULTS
>-There are no X defaults used by this program.
>-.SH "SEE ALSO"
>-X(1), xbench(1), x11perfcomp(1)
>-.SH AUTHORS
>-Joel McCormack
>-.br
>-Phil Karlton
>-.br
>-Susan Angebranndt
>-.br
>-Chris Kent
>-.br
>-Keith Packard
>-.br
>-Graeme Gill
>Index: xc/programs/xwd/Imakefile
>===================================================================
>RCS file: xc/programs/xwd/Imakefile
>diff -N xc/programs/xwd/Imakefile
>--- xc/programs/xwd/Imakefile	28 May 2002 01:50:57 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,8 +0,0 @@
>-XCOMM $Xorg: Imakefile,v 1.3 2000/08/17 19:55:11 cpqbld Exp $
>-        DEPLIBS = XkbClientDepLibs $(DEPXMULIB) $(DEPXLIB)
>-LOCAL_LIBRARIES = XkbClientLibs $(XMULIB) $(XLIB)
>-           SRCS = xwd.c dsimple.c list.c multiVis.c
>-           OBJS = xwd.o dsimple.o list.o multiVis.o
>-        DEFINES = XkbClientDefines
>-
>-ComplexProgramTarget(xwd)
>Index: xc/programs/xwd/dsimple.c
>===================================================================
>RCS file: xc/programs/xwd/dsimple.c
>diff -N xc/programs/xwd/dsimple.c
>--- xc/programs/xwd/dsimple.c	28 May 2002 01:50:57 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,515 +0,0 @@
>-/* $Xorg: dsimple.c,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
>-/*
>-
>-Copyright 1993, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>-*/
>-
>-#include <X11/Xos.h>
>-#include <X11/Xlib.h>
>-#include <X11/Xutil.h>
>-#include <X11/cursorfont.h>
>-#include <stdio.h>
>-/*
>- * Other_stuff.h: Definitions of routines in other_stuff.
>- *
>- * Written by Mark Lillibridge.   Last updated 7/1/87
>- */
>-
>-extern Bool silent;
>-unsigned long Resolve_Color();
>-Pixmap Bitmap_To_Pixmap();
>-Window Select_Window();
>-void out();
>-void blip();
>-Window Window_With_Name();
>-void Fatal_Error();
>-
>-/*
>- * Just_display: A group of routines designed to make the writting of simple
>- *               X11 applications which open a display but do not open
>- *               any windows much faster and easier.  Unless a routine says
>- *               otherwise, it may be assumed to require program_name, dpy,
>- *               and screen already defined on entry.
>- *
>- * Written by Mark Lillibridge.   Last updated 7/1/87
>- */
>-
>-
>-/* This stuff is defined in the calling program by just_display.h */
>-extern char *program_name;
>-extern Display *dpy;
>-extern int screen;
>-
>-
>-/*
>- * Malloc: like malloc but handles out of memory using Fatal_Error.
>- */
>-char *Malloc(size)
>-     unsigned size;
>-{
>-	char *data, *malloc();
>-
>-	if (!(data = malloc(size)))
>-	  Fatal_Error("Out of memory!");
>-
>-	return(data);
>-}
>-	
>-
>-/*
>- * Realloc: like Malloc except for realloc, handles NULL using Malloc.
>- */
>-char *Realloc(ptr, size)
>-        char *ptr;
>-        int size;
>-{
>-	char *new_ptr, *realloc();
>-
>-	if (!ptr)
>-	  return(Malloc(size));
>-
>-	if (!(new_ptr = realloc(ptr, size)))
>-	  Fatal_Error("Out of memory!");
>-
>-	return(new_ptr);
>-}
>-
>-
>-/*
>- * Get_Display_Name (argc, argv) Look for -display, -d, or host:dpy (obselete)
>- * If found, remove it from command line.  Don't go past a lone -.
>- */
>-char *Get_Display_Name(pargc, argv)
>-    int *pargc;  /* MODIFIED */
>-    char **argv; /* MODIFIED */
>-{
>-    int argc = *pargc;
>-    char **pargv = argv+1;
>-    char *displayname = NULL;
>-    int i;
>-
>-    for (i = 1; i < argc; i++) {
>-	char *arg = argv[i];
>-
>-	if (!strcmp (arg, "-display") || !strcmp (arg, "-d")) {
>-	    if (++i >= argc) usage ();
>-
>-	    displayname = argv[i];
>-	    *pargc -= 2;
>-	    continue;
>-	}
>-	if (!strcmp(arg,"-")) {
>-		while (i<argc)
>-			*pargv++ = argv[i++];
>-		break;
>-	}
>-	*pargv++ = arg;
>-    }
>-
>-    *pargv = NULL;
>-    return (displayname);
>-}
>-
>-
>-/*
>- * Open_Display: Routine to open a display with correct error handling.
>- *               Does not require dpy or screen defined on entry.
>- */
>-Display *Open_Display(display_name)
>-char *display_name;
>-{
>-	Display *d;
>-
>-	d = XOpenDisplay(display_name);
>-	if (d == NULL) {
>-	    fprintf (stderr, "%s:  unable to open display '%s'\n",
>-		     program_name, XDisplayName (display_name));
>-	    usage ();
>-	    /* doesn't return */
>-	}
>-
>-	return(d);
>-}
>-
>-
>-/*
>- * Setup_Display_And_Screen: This routine opens up the correct display (i.e.,
>- *                           it calls Get_Display_Name) and then stores a
>- *                           pointer to it in dpy.  The default screen
>- *                           for this display is then stored in screen.
>- *                           Does not require dpy or screen defined.
>- */
>-void Setup_Display_And_Screen(argc, argv)
>-int *argc;      /* MODIFIED */
>-char **argv;    /* MODIFIED */
>-{
>-	dpy = Open_Display (Get_Display_Name(argc, argv));
>-	screen = DefaultScreen(dpy);
>-}
>-
>-
>-/*
>- * Open_Font: This routine opens a font with error handling.
>- */
>-XFontStruct *Open_Font(name)
>-char *name;
>-{
>-	XFontStruct *font;
>-
>-	if (!(font=XLoadQueryFont(dpy, name)))
>-	  Fatal_Error("Unable to open font %s!", name);
>-
>-	return(font);
>-}
>-
>-
>-/*
>- * ReadBitmapFile: same as XReadBitmapFile except it returns the bitmap
>- *                 directly and handles errors using Fatal_Error.
>- */
>-static void _bitmap_error(status, filename)
>-     int status;
>-     char *filename;
>-{
>-  if (status == BitmapOpenFailed)
>-    Fatal_Error("Can't open file %s!", filename);
>-  else if (status == BitmapFileInvalid)
>-    Fatal_Error("file %s: Bad bitmap format.", filename);
>-  else
>-    Fatal_Error("Out of memory!");
>-}
>-
>-Pixmap ReadBitmapFile(d, filename, width, height, x_hot, y_hot)
>-     Drawable d;
>-     char *filename;
>-     int *width, *height, *x_hot, *y_hot;
>-{
>-  Pixmap bitmap;
>-  int status;
>-
>-  status = XReadBitmapFile(dpy, RootWindow(dpy, screen), filename,
>-			   (unsigned int *)width, (unsigned int *)height,
>-			   &bitmap, x_hot, y_hot);
>-  if (status != BitmapSuccess)
>-    _bitmap_error(status, filename);
>-
>-  return(bitmap);
>-}
>-
>-
>-/*
>- * WriteBitmapFile: same as XWriteBitmapFile except it handles errors
>- *                  using Fatal_Error.
>- */
>-void WriteBitmapFile(filename, bitmap, width, height, x_hot, y_hot)
>-     char *filename;
>-     Pixmap bitmap;
>-     int width, height, x_hot, y_hot;
>-{
>-  int status;
>-
>-  status= XWriteBitmapFile(dpy, filename, bitmap, width, height, x_hot,
>-			   y_hot);
>-  if (status != BitmapSuccess)
>-    _bitmap_error(status, filename);
>-}
>-
>-
>-/*
>- * Select_Window_Args: a rountine to provide a common interface for
>- *                     applications that need to allow the user to select one
>- *                     window on the screen for special consideration.
>- *                     This routine implements the following command line
>- *                     arguments:
>- *
>- *                       -root            Selects the root window.
>- *                       -id <id>         Selects window with id <id>. <id> may
>- *                                        be either in decimal or hex.
>- *                       -name <name>     Selects the window with name <name>.
>- *
>- *                     Call as Select_Window_Args(&argc, argv) in main before
>- *                     parsing any of your program's command line arguments.
>- *                     Select_Window_Args will remove its arguments so that
>- *                     your program does not have to worry about them.
>- *                     The window returned is the window selected or 0 if
>- *                     none of the above arguments was present.  If 0 is
>- *                     returned, Select_Window should probably be called after
>- *                     all command line arguments, and other setup is done.
>- *                     For examples of usage, see xwininfo, xwd, or xprop.
>- */
>-Window Select_Window_Args(rargc, argv)
>-     int *rargc;
>-     char **argv;
>-#define ARGC (*rargc)
>-{
>-	int nargc=1;
>-	int argc;
>-	char **nargv;
>-	Window w=0;
>-
>-	nargv = argv+1; argc = ARGC;
>-#define OPTION argv[0]
>-#define NXTOPTP ++argv, --argc>0
>-#define NXTOPT if (++argv, --argc==0) usage()
>-#define COPYOPT nargv++[0]=OPTION, nargc++
>-
>-	while (NXTOPTP) {
>-		if (!strcmp(OPTION, "-")) {
>-			COPYOPT;
>-			while (NXTOPTP)
>-			  COPYOPT;
>-			break;
>-		}
>-		if (!strcmp(OPTION, "-root")) {
>-			w=RootWindow(dpy, screen);
>-			continue;
>-		}
>-		if (!strcmp(OPTION, "-name")) {
>-			NXTOPT;
>-			w = Window_With_Name(dpy, RootWindow(dpy, screen),
>-					     OPTION);
>-			if (!w)
>-			  Fatal_Error("No window with name %s exists!",OPTION);
>-			continue;
>-		}
>-		if (!strcmp(OPTION, "-id")) {
>-			NXTOPT;
>-			w=0;
>-			sscanf(OPTION, "0x%lx", &w);
>-			if (!w)
>-			  sscanf(OPTION, "%ld", &w);
>-			if (!w)
>-			  Fatal_Error("Invalid window id format: %s.", OPTION);
>-			continue;
>-		}
>-		COPYOPT;
>-	}
>-	ARGC = nargc;
>-	
>-	return(w);
>-}
>-
>-/*
>- * Other_stuff: A group of routines which do common X11 tasks.
>- *
>- * Written by Mark Lillibridge.   Last updated 7/1/87
>- */
>-
>-extern Display *dpy;
>-extern int screen;
>-
>-/*
>- * Resolve_Color: This routine takes a color name and returns the pixel #
>- *                that when used in the window w will be of color name.
>- *                (WARNING:  The colormap of w MAY be modified! )
>- *                If colors are run out of, only the first n colors will be
>- *                as correct as the hardware can make them where n depends
>- *                on the display.  This routine does not require wind to
>- *                be defined.
>- */
>-unsigned long Resolve_Color(w, name)
>-     Window w;
>-     char *name;
>-{
>-	XColor c;
>-	Colormap colormap;
>-	XWindowAttributes wind_info;
>-
>-	/*
>-	 * The following is a hack to insure machines without a rgb table
>-	 * handle at least white & black right.
>-	 */
>-	if (!strcmp(name, "white"))
>-	  name="#ffffffffffff";
>-	if (!strcmp(name, "black"))
>-	  name="#000000000000";
>-
>-	XGetWindowAttributes(dpy, w, &wind_info);
>-	colormap = wind_info.colormap;
>-
>-	if (!XParseColor(dpy, colormap, name, &c))
>-	  Fatal_Error("Bad color format '%s'.", name);
>-
>-	if (!XAllocColor(dpy, colormap, &c))
>-	  Fatal_Error("XAllocColor failed!");
>-
>-	return(c.pixel);
>-}
>-
>-
>-/*
>- * Bitmap_To_Pixmap: Convert a bitmap to a 2 colored pixmap.  The colors come
>- *                   from the foreground and background colors of the gc.
>- *                   Width and height are required solely for efficiency.
>- *                   If needed, they can be obtained via. XGetGeometry.
>- */
>-Pixmap Bitmap_To_Pixmap(dpy, d, gc, bitmap, width, height)
>-     Display *dpy;
>-     Drawable d;
>-     GC gc;
>-     Pixmap bitmap;
>-     int width, height;
>-{
>-  Pixmap pix;
>-  int x;
>-  unsigned int i, depth;
>-  Drawable root;
>-
>-  if (!XGetGeometry(dpy, d, &root, &x, &x, &i, &i, &i, &depth))
>-    return(0);
>-
>-  pix = XCreatePixmap(dpy, d, width, height, (int)depth);
>-
>-  XCopyPlane(dpy, bitmap, pix, gc, 0, 0, width, height, 0, 0, 1);
>-
>-  return(pix);
>-}
>-
>-
>-/*
>- * blip: a debugging routine.  Prints Blip! on stderr with flushing. 
>- */
>-void blip()
>-{
>-  outl("blip!");
>-}
>-
>-
>-/*
>- * Routine to let user select a window using the mouse
>- */
>-
>-Window Select_Window(dpy)
>-     Display *dpy;
>-{
>-  int status;
>-  Cursor cursor;
>-  XEvent event;
>-  Window target_win = None, root = RootWindow(dpy,screen);
>-  int buttons = 0;
>-
>-  /* Make the target cursor */
>-  cursor = XCreateFontCursor(dpy, XC_crosshair);
>-
>-  /* Grab the pointer using target cursor, letting it room all over */
>-  status = XGrabPointer(dpy, root, False,
>-			ButtonPressMask|ButtonReleaseMask, GrabModeSync,
>-			GrabModeAsync, root, cursor, CurrentTime);
>-  if (status != GrabSuccess) Fatal_Error("Can't grab the mouse.");
>-
>-  /* Let the user select a window... */
>-  while ((target_win == None) || (buttons != 0)) {
>-    /* allow one more event */
>-    XAllowEvents(dpy, SyncPointer, CurrentTime);
>-    XWindowEvent(dpy, root, ButtonPressMask|ButtonReleaseMask, &event);
>-    switch (event.type) {
>-    case ButtonPress:
>-      if (target_win == None) {
>-	target_win = event.xbutton.subwindow; /* window selected */
>-	if (target_win == None) target_win = root;
>-      }
>-      buttons++;
>-      break;
>-    case ButtonRelease:
>-      if (buttons > 0) /* there may have been some down before we started */
>-	buttons--;
>-       break;
>-    }
>-  } 
>-
>-  XUngrabPointer(dpy, CurrentTime);      /* Done with pointer */
>-
>-  return(target_win);
>-}
>-
>-
>-/*
>- * Window_With_Name: routine to locate a window with a given name on a display.
>- *                   If no window with the given name is found, 0 is returned.
>- *                   If more than one window has the given name, the first
>- *                   one found will be returned.  Only top and its subwindows
>- *                   are looked at.  Normally, top should be the RootWindow.
>- */
>-Window Window_With_Name(dpy, top, name)
>-     Display *dpy;
>-     Window top;
>-     char *name;
>-{
>-	Window *children, dummy;
>-	unsigned int nchildren;
>-	int i;
>-	Window w=0;
>-	char *window_name;
>-
>-	if (XFetchName(dpy, top, &window_name) && !strcmp(window_name, name))
>-	  return(top);
>-
>-	if (!XQueryTree(dpy, top, &dummy, &dummy, &children, &nchildren))
>-	  return(0);
>-
>-	for (i=0; i<nchildren; i++) {
>-		w = Window_With_Name(dpy, children[i], name);
>-		if (w)
>-		  break;
>-	}
>-	if (children) XFree ((char *)children);
>-	return(w);
>-}
>-
>-/*
>- * outl: a debugging routine.  Flushes stdout then prints a message on stderr
>- *       and flushes stderr.  Used to print messages when past certain points
>- *       in code so we can tell where we are.  Outl may be invoked like
>- *       printf with up to 7 arguments.
>- */
>-/* VARARGS1 */
>-outl(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
>-     char *msg;
>-     char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
>-{
>-	fflush(stdout);
>-	fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
>-	fprintf(stderr, "\n");
>-	fflush(stderr);
>-}
>-
>-
>-/*
>- * Standard fatal error routine - call like printf but maximum of 7 arguments.
>- * Does not require dpy or screen defined.
>- */
>-/* VARARGS1 */
>-void Fatal_Error(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
>-char *msg;
>-char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
>-{
>-	fflush(stdout);
>-	fflush(stderr);
>-	fprintf(stderr, "%s: error: ", program_name);
>-	fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
>-	fprintf(stderr, "\n");
>-	exit(1);
>-}
>Index: xc/programs/xwd/dsimple.h
>===================================================================
>RCS file: xc/programs/xwd/dsimple.h
>diff -N xc/programs/xwd/dsimple.h
>--- xc/programs/xwd/dsimple.h	28 May 2002 01:50:57 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,79 +0,0 @@
>-/* $Xorg: dsimple.h,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
>-/*
>-
>-Copyright 1993, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>-*/
>-/*
>- * Just_display.h: This file contains the definitions needed to use the
>- *                 functions in just_display.c.  It also declares the global
>- *                 variables dpy, screen, and program_name which are needed to
>- *                 use just_display.c.
>- *
>- * Written by Mark Lillibridge.   Last updated 7/1/87
>- *
>- * Send bugs, etc. to chariot@athena.mit.edu.
>- */
>-
>-    /* Global variables used by routines in just_display.c */
>-
>-char *program_name = "unknown_program";       /* Name of this program */
>-Display *dpy;                                 /* The current display */
>-int screen;                                   /* The current screen */
>-
>-#define INIT_NAME program_name=argv[0]        /* use this in main to setup
>-                                                 program_name */
>-
>-    /* Declaritions for functions in just_display.c */
>-
>-void Fatal_Error();
>-char *Malloc();
>-char *Realloc();
>-char *Get_Display_Name();
>-Display *Open_Display();
>-void Setup_Display_And_Screen();
>-XFontStruct *Open_Font();
>-Pixmap ReadBitmapFile();
>-void WriteBitmapFile();
>-Window Select_Window_Args();
>-
>-#define X_USAGE "[host:display]"              /* X arguments handled by
>-						 Get_Display_Name */
>-#define SELECT_USAGE "[-root|-id <id>|-name <name>]"
>-
>-/*
>- * Other_stuff.h: Definitions of routines in other_stuff.
>- *
>- * Written by Mark Lillibridge.   Last updated 7/1/87
>- *
>- * Send bugs, etc. to chariot@athena.mit.edu.
>- */
>-
>-unsigned long Resolve_Color();
>-Pixmap Bitmap_To_Pixmap();
>-Window Select_Window();
>-void out();
>-void blip();
>-Window Window_With_Name();
>Index: xc/programs/xwd/list.c
>===================================================================
>RCS file: xc/programs/xwd/list.c
>diff -N xc/programs/xwd/list.c
>--- xc/programs/xwd/list.c	28 May 2002 01:50:57 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,293 +0,0 @@
>-/* $Xorg: list.c,v 1.5 2001/02/09 02:06:03 xorgcvs Exp $ */
>-/** ------------------------------------------------------------------------
>-	This file contains routines for manipulating generic lists.
>-	Lists are implemented with a "harness".  In other words, each
>-	node in the list consists of two pointers, one to the data item
>-	and one to the next node in the list.  The head of the list is
>-	the same struct as each node, but the "item" ptr is used to point
>-	to the current member of the list (used by the first_in_list and
>-	next_in_list functions).
>-
>-Copyright 1994 Hewlett-Packard Co.
>-Copyright 1996, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>-  ----------------------------------------------------------------------- **/
>-
>-#include <stdio.h>
>-#include "list.h"
>-
>-
>-/** ------------------------------------------------------------------------
>-	Sets the pointers of the specified list to NULL.
>-    --------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-void zero_list(list_ptr lp)
>-#else
>-void zero_list(lp)
>-    list_ptr lp;
>-#endif
>-{
>-    lp->next = NULL;
>-    lp->ptr.item = NULL;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Adds item to the list pointed to by lp.  Finds the end of the
>-	list, then mallocs a new list node onto the end of the list.
>-	The item pointer in the new node is set to "item" passed in,
>-	and the next pointer in the new node is set to NULL.
>-	Returns 1 if successful, 0 if the malloc failed.
>-    -------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-int add_to_list(list_ptr lp, void *item)
>-#else
>-int add_to_list(lp, item)
>-    list_ptr lp;
>-    void *item;
>-#endif
>-{
>-    while (lp->next) {
>-	lp = lp->next;
>-    }
>-    if ((lp->next = (list_ptr) malloc( sizeof( list_item))) == NULL) {
>-
>-	return 0;
>-    }
>-    lp->next->ptr.item = item;
>-    lp->next->next = NULL;
>-
>-    return 1;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Creates a new list and sets its pointers to NULL.  
>-	Returns a pointer to the new list.
>-    -------------------------------------------------------------------- **/
>-list_ptr new_list ()
>-{
>-    list_ptr lp;
>-
>-    if ((lp = (list_ptr) malloc( sizeof( list_item)))) {
>-	lp->next = NULL;
>-	lp->ptr.item = NULL;
>-    }
>-
>-    return lp;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Creates a new list head, pointing to the same list as the one
>-	passed in.  If start_at_curr is TRUE, the new list's first item
>-	is the "current" item (as set by calls to first/next_in_list()).
>-	If start_at_curr is FALSE, the first item in the new list is the
>-	same as the first item in the old list.  In either case, the
>-	curr pointer in the new list is the same as in the old list.
>-	Returns a pointer to the new list head.
>-    -------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-list_ptr dup_list_head(list_ptr lp, int start_at_curr)
>-#else
>-list_ptr dup_list_head(lp, start_at_curr)
>-    list_ptr lp;
>-    int start_at_curr;
>-#endif
>-{
>-    list_ptr new_list;
>-
>-    if ((new_list = (list_ptr) malloc( sizeof( list_item))) == NULL) {
>-
>-        return (list_ptr)NULL;
>-    }
>-    new_list->next = start_at_curr ? lp->ptr.curr : lp->next;
>-    new_list->ptr.curr = lp->ptr.curr;
>-
>-    return new_list;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Returns the number of items in the list.
>-    -------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-unsigned int list_length(list_ptr lp)
>-#else
>-unsigned int list_length(lp)
>-    list_ptr lp;
>-#endif
>-{
>-    unsigned int count = 0;
>-
>-    while (lp->next) {
>-	count++;
>-	lp = lp->next;
>-    }
>-
>-    return count;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Scans thru list, looking for a node whose ptr.item is equal to
>-	the "item" passed in.  "Equal" here means the same address - no
>-	attempt is made to match equivalent values stored in different
>-	locations.  If a match is found, that node is deleted from the
>-	list.  Storage for the node is freed, but not for the item itself.
>-	Returns a pointer to the item, so the caller can free it if it
>-	so desires.  If a match is not found, returns NULL.
>-    -------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-void *delete_from_list(list_ptr lp, void *item)
>-#else
>-void *delete_from_list(lp, item)
>-    list_ptr lp;
>-    void *item;
>-#endif
>-{
>-    list_ptr new_next;
>-
>-    while (lp->next) {
>-	if (lp->next->ptr.item == item) {
>-	    new_next = lp->next->next;
>-	    free (lp->next);
>-	    lp->next = new_next;
>-
>-	    return item;
>-	}
>-	lp = lp->next;
>-    }
>-
>-    return NULL;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Deletes each node in the list *except the head*.  This allows
>-	the deletion of lists where the head is not malloced or created
>-	with new_list().  If free_items is true, each item pointed to 
>-	from the node is freed, in addition to the node itself.
>-    -------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-void delete_list(list_ptr lp, int free_items)
>-#else
>-void delete_list(lp, free_items)
>-    list_ptr lp;
>-    int free_items;
>-#endif
>-{
>-    list_ptr del_node;
>-    void *item;
>-
>-    while (lp->next) {
>-	del_node = lp->next;
>-	item = del_node->ptr.item;
>-	lp->next = del_node->next;
>-	free (del_node);
>-	if (free_items) {
>-	    free( item);
>-	}
>-    }
>-}
>-
>-#if NeedFunctionPrototypes
>-void delete_list_destroying(list_ptr lp, void destructor(void *item))
>-#else
>-void delete_list_destroying(lp, destructor)
>-    list_ptr lp;
>-    void (*destructor)();
>-#endif
>-{
>-    list_ptr del_node;
>-    void *item;
>-
>-    while (lp->next) {
>-	del_node = lp->next;
>-	item = del_node->ptr.item;
>-	lp->next = del_node->next;
>-	free( del_node);
>-	if (destructor) {
>-	    destructor( item);
>-	}
>-    }
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Returns a ptr to the first *item* (not list node) in the list.
>-	Sets the list head node's curr ptr to the first node in the list.
>-	Returns NULL if the list is empty.
>-    -------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-void * first_in_list(list_ptr lp)
>-#else
>-void * first_in_list(lp)
>-    list_ptr lp;
>-#endif
>-{
>-    if (! lp) {
>-
>-	return NULL;
>-    }
>-    lp->ptr.curr = lp->next;
>-
>-    return lp->ptr.curr ? lp->ptr.curr->ptr.item : NULL;
>-}
>-
>-/** ------------------------------------------------------------------------
>-	Returns a ptr to the next *item* (not list node) in the list.
>-	Sets the list head node's curr ptr to the next node in the list.
>-	first_in_list must have been called prior.
>-	Returns NULL if no next item.
>-    -------------------------------------------------------------------- **/
>-#if NeedFunctionPrototypes
>-void * next_in_list(list_ptr lp)
>-#else
>-void * next_in_list(lp)
>-    list_ptr lp;
>-#endif
>-{
>-    if (! lp) {
>-
>-	return NULL;
>-    }
>-    if (lp->ptr.curr) {
>-	lp->ptr.curr = lp->ptr.curr->next;
>-    }
>-
>-    return lp->ptr.curr ? lp->ptr.curr->ptr.item : NULL;
>-}
>-
>-#if NeedFunctionPrototypes
>-int list_is_empty(list_ptr lp)
>-#else
>-int list_is_empty(lp)
>-    list_ptr lp;
>-#endif
>-{
>-    return (lp == NULL || lp->next == NULL);
>-}
>-
>Index: xc/programs/xwd/list.h
>===================================================================
>RCS file: xc/programs/xwd/list.h
>diff -N xc/programs/xwd/list.h
>--- xc/programs/xwd/list.h	28 May 2002 01:50:57 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,117 +0,0 @@
>-/* $Xorg: list.h,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
>-/** ------------------------------------------------------------------------
>-	This file contains routines for manipulating generic lists.
>-	Lists are implemented with a "harness".  In other words, each
>-	node in the list consists of two pointers, one to the data item
>-	and one to the next node in the list.  The head of the list is
>-	the same struct as each node, but the "item" ptr is used to point
>-	to the current member of the list (used by the first_in_list and
>-	next_in_list functions).
>-
>-Copyright 1994 Hewlett-Packard Co.
>-Copyright 1996, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>-    -------------------------------------------------------------------- **/
>-
>-#ifndef LIST_DEF
>-#define LIST_DEF
>-
>-#define LESS	-1
>-#define EQUAL	0
>-#define GREATER	1
>-#define DUP_WHOLE_LIST	0
>-#define START_AT_CURR	1
>-
>-typedef struct _list_item {
>-    struct _list_item *next;
>-    union {
>-	void *item;		 /* in normal list node, pts to data */
>-	struct _list_item *curr; /* in list head, pts to curr for 1st, next */
>-    } ptr;
>-} list, list_item, *list_ptr;
>-
>-typedef void (*DESTRUCT_FUNC_PTR)(
>-#if NeedFunctionPrototypes
>-void *
>-#endif
>-);
>-
>-void zero_list( 
>-#if NeedFunctionPrototypes
>-          list_ptr 
>-#endif
>-    );
>-int add_to_list (
>-#if NeedFunctionPrototypes
>-          list_ptr , void *
>-#endif
>-    );
>-list_ptr new_list (
>-#if NeedFunctionPrototypes
>-          void
>-#endif
>-    );
>-list_ptr dup_list_head (
>-#if NeedFunctionPrototypes
>-          list_ptr , int 
>-#endif
>-    );
>-unsigned int list_length( 
>-#if NeedFunctionPrototypes
>-          list_ptr 
>-#endif
>-    );
>-void *delete_from_list (
>-#if NeedFunctionPrototypes
>-          list_ptr , void *
>-#endif
>-    );
>-void delete_list( 
>-#if NeedFunctionPrototypes
>-          list_ptr , int 
>-#endif
>-    );
>-void delete_list_destroying (
>-#if NeedFunctionPrototypes
>-          list_ptr , DESTRUCT_FUNC_PTR
>-#endif
>-    );
>-void *first_in_list (
>-#if NeedFunctionPrototypes
>-          list_ptr 
>-#endif
>-    );
>-void *next_in_list (
>-#if NeedFunctionPrototypes
>-          list_ptr 
>-#endif
>-    );
>-int list_is_empty (
>-#if NeedFunctionPrototypes
>-          list_ptr 
>-#endif
>-    );
>-
>-#endif
>Index: xc/programs/xwd/multiVis.c
>===================================================================
>RCS file: xc/programs/xwd/multiVis.c
>diff -N xc/programs/xwd/multiVis.c
>--- xc/programs/xwd/multiVis.c	28 May 2002 01:50:57 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,1249 +0,0 @@
>-/* $Xorg: multiVis.c,v 1.5 2001/02/09 02:06:03 xorgcvs Exp $ */
>-/** ------------------------------------------------------------------------
>-	This file contains functions to create a list of regions which
>-	tile a specified window.  Each region contains all visible 
>-	portions of the window which are drawn with the same visual.
>-	If the window consists of subwindows of two different visual types,
>-	there will be two regions in the list.  The list can be traversed
>-	to correctly pull an image of the window using XGetImage or the
>-	Image Library.
>-
>-Copyright 1994 Hewlett-Packard Co.
>-Copyright 1996, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>-    ------------------------------------------------------------------------ **/
>-#include <stdlib.h>
>-#include <X11/Xlib.h>
>-#include <X11/Xutil.h>
>-#include <X11/X.h>
>-#include <stdio.h>
>-#include "list.h"
>-#include "wsutils.h"
>-#include "multiVis.h"
>-static char *vis_class_str[] = { "StaticGray" , "GrayScale" , "StaticColor",
>-				 "PseudoColor","TrueColor","DirectColor" } ;
>-/* These structures are copied from X11/region.h.  For some reason
>- * they're invisible from the outside.
>- */
>-typedef struct {
>-    short x1, x2, y1, y2;
>-} myBox, myBOX, myBoxRec, *myBoxPtr;
>-
>-typedef struct my_XRegion {
>-    long size;
>-    long numRects;
>-    myBOX *rects;
>-    myBOX extents;
>-} myREGION;
>-
>-/* Items in long list of windows that have some part in the grabbed area */
>-typedef struct {
>-    Window win;
>-    Visual *vis;
>-    Colormap cmap;
>-    int x_rootrel, y_rootrel;	/* root relative location of window */
>-    int x_vis, y_vis;  		/* rt rel x,y of vis part, not parent clipped */
>-    int width, height; 		/* width and height of visible part */
>-    int border_width;		/* border width of the window */
>-    Window parent;		/* id of parent (for debugging) */
>-} image_win_type;
>-
>-/*  Items in short list of regions that tile the grabbed area.  May have 
>-    multiple windows in the region.
>-*/
>-typedef struct {
>-    Window win;			/* lowest window of this visual */
>-    Visual *vis;
>-    Colormap cmap;
>-    int x_rootrel, y_rootrel;	/* root relative location of bottom window */
>-    int x_vis, y_vis;  		/* rt rel x,y of vis part, not parent clipped */
>-    int width, height;		/* w & h of visible rect of bottom window */
>-    int border;			/* border width of the window */
>-    Region visible_region;
>-} image_region_type;
>-
>-/** ------------------------------------------------------------------------
>-	Returns TRUE if the two structs pointed to have the same "vis" & 
>-	"cmap" fields and s2 lies completely within s1.  s1 and s2 can
>-	point to structs of image_win_type or image_region_type.
>-    ------------------------------------------------------------------------ **/
>-#define SAME_REGIONS( s1, s2)	\
>-	((s1)->vis == (s2)->vis && (s1)->cmap == (s2)->cmap &&   	\
>-	 (s1)->x_vis <= (s2)->x_vis &&				    \
>-	 (s1)->y_vis <= (s2)->y_vis &&				    \
>-	 (s1)->x_vis + (s1)->width  >= (s2)->x_vis + (s2)->width && \
>-	 (s1)->y_vis + (s1)->height >= (s2)->y_vis + (s2)->height)
>-
>-#ifndef MIN
>-#define MIN( a, b)	((a) < (b) ? a : b)
>-#define MAX( a, b)	((a) > (b) ? a : b)
>-#endif
>-
>-#define	RED_SHIFT        16
>-#define GREEN_SHIFT       8
>-#define BLUE_SHIFT        0
>-
>-/*
>-extern list_ptr	new_list();
>-extern list_ptr	dup_list_head();
>-extern void *	first_in_list();
>-extern void *	next_in_list();
>-extern int	add_to_list();
>-extern void	zero_list();
>-extern void	delete_list();
>-extern void	delete_list_destroying();
>-extern unsigned int list_length();
>-*/
>-
>-/* Prototype Declarations for Static Functions */
>-static int QueryColorMap(
>-#if NeedFunctionPrototypes
>-           Display *, Colormap , Visual *, 
>-           XColor **, int *, int *, int *
>-#endif
>-	   );
>-static void TransferImage(
>-#if NeedFunctionPrototypes
>-           Display *, XImage *,int, int , image_region_type*,
>-           XImage *,int ,int 
>-#endif
>-	   );
>-static XImage * ReadRegionsInList(
>-#if NeedFunctionPrototypes
>-           Display *, Visual *, int ,int ,int ,
>-           int , XRectangle, list_ptr 
>-#endif
>-           );
>-
>-static list_ptr make_region_list( 
>-#if NeedFunctionPrototypes
>-                  Display*, Window, XRectangle*,
>-                  int*, int, XVisualInfo**, int	*
>-#endif
>-         );
>-
>-static void destroy_region_list( 
>-#if NeedFunctionPrototypes
>-            list_ptr 
>-#endif
>-            ) ;
>-static void subtr_rect_from_image_region( 
>-#if NeedFunctionPrototypes
>-           image_region_type *, int , int , int , int 
>-#endif
>-     );
>-static void add_rect_to_image_region( 
>-#if NeedFunctionPrototypes
>-           image_region_type *,
>-           int , int , int , int 
>-#endif
>-     );
>-static int src_in_region_list( 
>-#if NeedFunctionPrototypes
>-    image_win_type *, list_ptr 
>-#endif
>-    );
>-static void add_window_to_list(
>-#if NeedFunctionPrototypes
>-    list_ptr, Window, int, int ,
>-    int	, int , int , int, int,
>-    Visual*, Colormap, Window
>-#endif
>-    );
>-static int src_in_image( 
>-#if NeedFunctionPrototypes
>-    image_win_type 	*, int	, XVisualInfo**
>-#endif
>-    );
>-static int src_in_overlay( 
>-#if NeedFunctionPrototypes
>-    image_region_type *, int, OverlayInfo *, int*, int*
>-#endif 
>-    );
>-
>-/* End of Prototype Declarations */
>-
>-void initFakeVisual(Vis)
>-Visual *Vis ;
>-{
>-    Vis->ext_data=NULL;
>-    Vis->class = DirectColor ;
>-    Vis->red_mask =   0x00FF0000;
>-    Vis->green_mask = 0x0000FF00 ;
>-    Vis->blue_mask  = 0x000000FF ;
>-    Vis->map_entries = 256 ;
>-    Vis->bits_per_rgb = 8 ;
>-}
>-
>-static int
>-QueryColorMap(disp,src_cmap,src_vis,src_colors,rShift,gShift,bShift)
>-Display *disp ;
>-Visual *src_vis ;
>-Colormap src_cmap ;
>-XColor **src_colors ;
>-int *rShift, *gShift, *bShift;
>-{
>-     int ncolors,i ;
>-     unsigned long       redMask, greenMask, blueMask;
>-     int                 redShift, greenShift, blueShift;
>-     XColor *colors ;
>-
>-     ncolors = src_vis->map_entries ;
>-     *src_colors = colors = (XColor *)malloc(ncolors * sizeof(XColor) ) ;
>-
>-     if(src_vis->class != TrueColor && src_vis->class != DirectColor)
>-     {
>-         for(i=0 ; i < ncolors ; i++)
>-         {
>-	        colors[i].pixel = i ;
>-                colors[i].pad = 0;
>-                colors[i].flags = DoRed|DoGreen|DoBlue;
>-         }
>-     }
>-     else /** src is decomposed rgb ***/
>-     {
>-        /* Get the X colormap */
>-        redMask = src_vis->red_mask;
>-        greenMask = src_vis->green_mask;
>-        blueMask = src_vis->blue_mask;
>-        redShift = 0; while (!(redMask&0x1)) {
>-                redShift++;
>-                redMask = redMask>>1;
>-        }
>-        greenShift = 0; while (!(greenMask&0x1)) {
>-                greenShift++;
>-                greenMask = greenMask>>1;
>-        }
>-        blueShift = 0; while (!(blueMask&0x1)) {
>-                blueShift++;
>-                blueMask = blueMask>>1;
>-        }
>-	*rShift = redShift ;
>-	*gShift = greenShift ;
>-	*bShift = blueShift ;
>-        for (i=0; i<ncolors; i++) {
>-		if( i <= redMask)colors[i].pixel = (i<<redShift) ;
>-		if( i <= greenMask)colors[i].pixel |= (i<<greenShift) ;
>-		if( i <= blueMask)colors[i].pixel |= (i<<blueShift) ;
>-		/***** example :for gecko's 3-3-2 map, blue index should be <= 3.
>-                colors[i].pixel = (i<<redShift)|(i<<greenShift)|(i<<blueShift);
>-		*****/
>-                colors[i].pad = 0;
>-                colors[i].flags = DoRed|DoGreen|DoBlue;
>-        }
>-      }
>-
>-
>-      XQueryColors(disp, src_cmap, colors, ncolors);
>-      return ncolors ;
>-}
>-
>-int
>-GetMultiVisualRegions(disp,srcRootWinid, x, y, width, height,
>-    transparentOverlays,numVisuals, pVisuals,numOverlayVisuals, pOverlayVisuals,
>-    numImageVisuals, pImageVisuals,vis_regions,vis_image_regions,allImage)
>-    Display             *disp;
>-    Window              srcRootWinid;   /* root win on which grab was done */
>-    int                 x;      /* root rel UL corner of bounding box of grab */
>-    int                 y;
>-    unsigned int        width;  /* size of bounding box of grab */
>-    unsigned int        height;
>-    int                 *transparentOverlays ;
>-    int                 *numVisuals;
>-    XVisualInfo         **pVisuals;
>-    int                 *numOverlayVisuals;
>-    OverlayInfo         **pOverlayVisuals;
>-    int                 *numImageVisuals;
>-    XVisualInfo         ***pImageVisuals;
>-    list_ptr            *vis_regions;    /* list of regions to read from */
>-    list_ptr            *vis_image_regions ; 
>-    int			*allImage ;
>-{
>-    int                 hasNonDefault;
>-    XRectangle          bbox;           /* bounding box of grabbed area */
>-
>-
>-    bbox.x = x;                 /* init X rect for bounding box */
>-    bbox.y = y;
>-    bbox.width = width;
>-    bbox.height = height;
>-
>-    GetXVisualInfo(disp,DefaultScreen(disp),
>-                    transparentOverlays,
>-                    numVisuals, pVisuals,
>-                    numOverlayVisuals, pOverlayVisuals,
>-                    numImageVisuals, pImageVisuals);
>-
>-    *vis_regions = *vis_image_regions = NULL ;
>-    if ((*vis_regions = make_region_list( disp, srcRootWinid, &bbox,
>-                                         &hasNonDefault, *numImageVisuals,
>-                                         *pImageVisuals, allImage)) == NULL) 
>-    	return 0 ;
>-   
>-    if (*transparentOverlays)
>-    {
>-        *allImage = 1; /* until proven otherwise,
>-                         this flags that it to be an image only list */
>-        *vis_image_regions =
>-                make_region_list( disp, srcRootWinid, &bbox, &hasNonDefault,
>-                                        *numImageVisuals, *pImageVisuals, allImage);
>-    }
>-
>-    /* if there is a second region in any of the two lists return 1 **/
>-    if ( ( *vis_regions && (*vis_regions)->next && (*vis_regions)->next->next ) ||
>-         ( *vis_image_regions && (*vis_image_regions)->next && 
>-           (*vis_image_regions)->next->next ) ) return 1 ;
>-    else return 0 ;
>-
>-}
>-
>-static void TransferImage(disp,reg_image,srcw,srch,reg,
>-			  target_image,dst_x,dst_y)
>-Display *disp;
>-XImage *reg_image,*target_image ;
>-image_region_type	*reg;
>-int srcw,srch,dst_x , dst_y ;
>-{
>-    int ncolors;
>-    int i,j,old_pixel,new_pixel,red_ind,green_ind,blue_ind ;
>-    XColor *colors;
>-    int rShift,gShift,bShift;
>-    int targetBytesPerLine ;
>-
>-    ncolors = QueryColorMap(disp,reg->cmap,reg->vis,&colors,
>-	 &rShift,&gShift,&bShift) ;
>-
>-    targetBytesPerLine = target_image->bytes_per_line;  
>-
>-    switch (reg->vis->class) {
>-    case TrueColor : 
>-       for(i=0 ; i < srch ; i++)
>-       {
>-         for(j=0 ; j < srcw ;  j++)
>-         {
>-	   old_pixel = XGetPixel(reg_image,j,i) ;
>-
>-           if( reg->vis->map_entries == 16) {
>-	
>-                 red_ind = (old_pixel & reg->vis->red_mask) >> rShift ;
>-	         green_ind = (old_pixel & reg->vis->green_mask) >> gShift ;
>-	         blue_ind = (old_pixel & reg->vis->blue_mask) >> bShift ;
>-
>-	         new_pixel = ( 
>-			      ((colors[red_ind].red >> 8) << RED_SHIFT)
>-			      |((colors[green_ind].green >> 8) << GREEN_SHIFT)
>-			      |((colors[blue_ind].blue >> 8) << BLUE_SHIFT)
>-                             );
>-           }
>-	   else  
>-		new_pixel = old_pixel;
>-
>-           XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);
>-	   
>-         }
>-       }
>-       break;
>-    case DirectColor :
>-       for(i=0 ; i < srch ; i++)
>-       {
>-	 
>-         for(j=0 ; j < srcw ;  j++)
>-         {
>-	   old_pixel = XGetPixel(reg_image,j,i) ;
>-           red_ind = (old_pixel & reg->vis->red_mask) >> rShift ;
>-	   green_ind = (old_pixel & reg->vis->green_mask) >> gShift ;
>-	   blue_ind = (old_pixel & reg->vis->blue_mask) >> bShift ;
>-	
>-	   new_pixel = ( 
>-			 ((colors[red_ind].red >> 8) << RED_SHIFT)
>-			|((colors[green_ind].green >> 8) << GREEN_SHIFT)
>-			|((colors[blue_ind].blue >> 8) << BLUE_SHIFT)
>-                       );
>-           XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);
>-	   
>-         }
>-       }
>-       break;
>-    default :
>-       for(i=0 ; i < srch ; i++)
>-       {
>-         for(j=0 ; j < srcw ;  j++)
>-         {
>-	    old_pixel = XGetPixel(reg_image,j,i) ;
>-	
>-	   new_pixel = ( 
>-			 ((colors[old_pixel].red >> 8) << RED_SHIFT)
>-			|((colors[old_pixel].green >> 8) << GREEN_SHIFT)
>-			|((colors[old_pixel].blue >> 8) << BLUE_SHIFT)
>-                       );
>-           XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);
>-	  
>-         }
>-       }
>-       break;
>-    }
>-}
>-
>-static XImage *
>-ReadRegionsInList(disp,fakeVis,depth,format,width,height,bbox,regions) 
>-Display *disp ;
>-Visual *fakeVis ;
>-int depth , width , height ;
>-int format ;
>-XRectangle	bbox;		/* bounding box of grabbed area */
>-list_ptr regions;/* list of regions to read from */
>-{
>-    image_region_type	*reg;
>-    int			dst_x, dst_y;	/* where in pixmap to write (UL) */
>-    int			diff;
>-
>-    XImage		*reg_image,*ximage ;
>-    int			srcRect_x,srcRect_y,srcRect_width,srcRect_height ;
>-    int                 rem ;  
>-    int                 bytes_per_line;   
>-    int                 bitmap_unit; 
>-    
>-    bitmap_unit = sizeof (long);
>-    if (format == ZPixmap)
>-       bytes_per_line = width*depth/8;
>-    else
>-       bytes_per_line = width/8;
>-   
>-
>-    /* Find out how many more bytes are required for padding so that
>-    ** bytes per scan line will be multiples of bitmap_unit bits */
>-    if (format == ZPixmap) {
>-       rem = (bytes_per_line*8)%bitmap_unit; 
>-    if (rem)
>-       bytes_per_line += (rem/8 + 1);
>-    }
>-
>-    ximage = XCreateImage(disp,fakeVis,depth,format,0,NULL,width,height,
>-	         8,0) ;
>-    bytes_per_line = ximage->bytes_per_line;
>-
>-    if (format == ZPixmap)
>-    	  ximage->data = malloc(height*bytes_per_line);
>-    else
>-        ximage->data = malloc(height*bytes_per_line*depth);
>-
>-    ximage->bits_per_pixel = depth; /** Valid only if format is ZPixmap ***/
>-    
>-    for (reg = (image_region_type *) first_in_list( regions); reg;
>-	 reg = (image_region_type *) next_in_list( regions)) 
>-    {
>-		int rect;
>-		struct my_XRegion *vis_reg;
>-		vis_reg = (struct my_XRegion *)(reg->visible_region);
>-		for (rect = 0; 
>-		     rect < vis_reg->numRects;
>-		     rect++)
>-		{
>-		/** ------------------------------------------------------------------------
>-			Intersect bbox with visible part of region giving src rect & output 
>-			location.  Width is the min right side minus the max left side.
>-			Similar for height.  Offset src rect so x,y are relative to
>-			origin of win, not the root-relative visible rect of win.
>-		    ------------------------------------------------------------------------ **/
>-		    srcRect_width  = MIN( vis_reg->rects[rect].x2, bbox.width + bbox.x) - 
>-				     MAX( vis_reg->rects[rect].x1, bbox.x);
>-		    srcRect_height = MIN( vis_reg->rects[rect].y2, bbox.height + bbox.y) - 
>-				     MAX( vis_reg->rects[rect].y1, bbox.y);
>-		    diff = bbox.x - vis_reg->rects[rect].x1;
>-		    srcRect_x = MAX( 0, diff)  + (vis_reg->rects[rect].x1 - reg->x_rootrel - reg->border);
>-		    dst_x     = MAX( 0, -diff) ;
>-		    diff = bbox.y - vis_reg->rects[rect].y1;
>-		    srcRect_y = MAX( 0, diff)  + (vis_reg->rects[rect].y1 - reg->y_rootrel - reg->border);
>-		    dst_y     = MAX( 0, -diff) ;
>-                    reg_image = XGetImage(disp,reg->win,srcRect_x,srcRect_y,
>-				srcRect_width,srcRect_height,AllPlanes,format) ;
>-		    TransferImage(disp,reg_image,srcRect_width,
>-		                 srcRect_height,reg,ximage,dst_x,dst_y) ;
>-	    }
>-    }
>-    return ximage ;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-    ------------------------------------------------------------------------ **/
>-
>-XImage *ReadAreaToImage(disp, srcRootWinid, x, y, width, height, 
>-    numVisuals,pVisuals,numOverlayVisuals,pOverlayVisuals,numImageVisuals,
>-    pImageVisuals,vis_regions,vis_image_regions,format,allImage)
>-    Display		*disp;
>-    Window		srcRootWinid;	/* root win on which grab was done */
>-    int			x;   /* root rel UL corner of bounding box of grab */
>-    int			y;
>-    unsigned int	width;	/* size of bounding box of grab */
>-    unsigned int	height;
>-    /** int			transparentOverlays; ***/
>-    int			numVisuals;
>-    XVisualInfo		*pVisuals;
>-    int			numOverlayVisuals; 
>-    OverlayInfo		*pOverlayVisuals;
>-    int			numImageVisuals;
>-    XVisualInfo		**pImageVisuals;
>-    list_ptr		vis_regions;	/* list of regions to read from */
>-    list_ptr		vis_image_regions ;/* list of regions to read from */
>-    int			format;
>-    int 		allImage ;
>-{
>-    image_region_type	*reg;
>-    XRectangle		bbox;		/* bounding box of grabbed area */
>-    int 		depth ;
>-    XImage		*ximage, *ximage_ipm ;
>-    Visual		fakeVis ;
>-    int 	x1, y1;
>-    XImage	*image;
>-    unsigned char 	*pmData ,  *ipmData ;
>-    int                 transparentColor, transparentType;
>-    int			srcRect_x,srcRect_y,srcRect_width,srcRect_height ;
>-    int			diff ;
>-    int			dst_x, dst_y;	/* where in pixmap to write (UL) */
>-    int			pixel;
>-
>-    bbox.x = x;			/* init X rect for bounding box */
>-    bbox.y = y;
>-    bbox.width = width;
>-    bbox.height = height;
>-
>-
>-    initFakeVisual(&fakeVis) ;
>-
>-    depth = 24 ;
>-    ximage = ReadRegionsInList(disp,&fakeVis,depth,format,width,height,
>-	     bbox,vis_regions) ;
>-    pmData = (unsigned char *)ximage -> data ;
>-
>-/* if transparency possible do it again, but this time for image planes only */
>-    if (vis_image_regions && (vis_image_regions->next) && !allImage)
>-    {
>-	ximage_ipm = ReadRegionsInList(disp,&fakeVis,depth,format,width,height,
>-		     bbox,vis_image_regions) ;
>-        ipmData = (unsigned char *)ximage_ipm -> data ;
>-    }
>-/* Now tranverse the overlay visual windows and test for transparency index.  */
>-/* If you find one, subsitute the value from the matching image plane pixmap. */
>-
>-    for (reg = (image_region_type *) first_in_list( vis_regions); reg;
>-	 reg = (image_region_type *) next_in_list( vis_regions))
>-    {
>-
>-	if (src_in_overlay( reg, numOverlayVisuals, pOverlayVisuals,
>-				 &transparentColor, &transparentType))
>-	{
>-	int test = 0 ;
>-	     srcRect_width  = MIN( reg->width + reg->x_vis, bbox.width + bbox.x)
>-				 - MAX( reg->x_vis, bbox.x);
>-	     srcRect_height = MIN( reg->height + reg->y_vis, bbox.height 
>-				 + bbox.y) - MAX( reg->y_vis, bbox.y);
>-             diff = bbox.x - reg->x_vis;
>-             srcRect_x = MAX( 0, diff)  + (reg->x_vis - reg->x_rootrel - reg->border);
>-             dst_x     = MAX( 0, -diff) ;
>-	     diff = bbox.y - reg->y_vis;
>-	     srcRect_y = MAX( 0, diff)  + (reg->y_vis - reg->y_rootrel - reg->border);
>-	     dst_y     = MAX( 0, -diff) ;
>-	/* let's test some pixels for transparency */
>-             image = XGetImage(disp, reg->win, srcRect_x, srcRect_y, 
>-		 srcRect_width, srcRect_height, 0xffffffff, ZPixmap);
>-
>-        /* let's assume byte per pixel for overlay image for now */
>-	     if ((image->depth == 8) && (transparentType == TransparentPixel))
>-	     {
>-	         unsigned char *pixel_ptr;
>-	         unsigned char *start_of_line = (unsigned char *) image->data;
>-
>-	         for (y1 = 0; y1 < srcRect_height; y1++) {
>-		    pixel_ptr = start_of_line;
>-		    for (x1 = 0; x1 < srcRect_width; x1++)
>-		    {
>-			if (*pixel_ptr++ == transparentColor)
>-			{
>-			/*
>-			    *pmData++ = *ipmData++;
>-			    *pmData++ = *ipmData++;
>-			    *pmData++ = *ipmData++;
>-			*/
>-	                pixel = XGetPixel(ximage_ipm,dst_x+x1,dst_y+y1) ;
>-                        XPutPixel(ximage,dst_x+x1, dst_y+y1,pixel);
>-			    
>-			if(!test){
>-			   test = 1 ;
>-			}
>-			}
>-			/*
>-			else {
>-			    pmData +=3;
>-			    ipmData +=3;
>-			}
>-			*/
>-		    }
>-		    start_of_line += image->bytes_per_line;
>-		}
>-	} else {
>-		if (transparentType == TransparentPixel) {
>-		for (y1 = 0; y1 < srcRect_height; y1++) {
>-		      for (x1 = 0; x1 < srcRect_width; x1++)
>-		      {
>-			    int pixel_value = XGetPixel(image, x1, y1);
>-			    if (pixel_value == transparentColor)
>-			    {
>-			    /*
>-				*pmData++ = *ipmData++;
>-				*pmData++ = *ipmData++;
>-				*pmData++ = *ipmData++;
>-			    */
>-	                pixel = XGetPixel(ximage_ipm,dst_x+x1,dst_y+y1) ;
>-                        XPutPixel(ximage,dst_x+x1, dst_y+y1,pixel);
>-			if(!test){
>-			   test = 1 ;
>-			}
>-			    }
>-			    /*
>-			    else {
>-				pmData +=3;
>-				ipmData +=3;
>-			    }
>-			    */
>-			}
>-		    }
>-		} else {
>-		    for (y1 = 0; y1 < srcRect_height; y1++) {
>-			for (x1 = 0; x1 < srcRect_width; x1++)
>-			{
>-			    int pixel_value = XGetPixel(image, x1, y1);
>-			    if (pixel_value & transparentColor)
>-			    {
>-			    /*
>-				*pmData++ = *ipmData++;
>-				*pmData++ = *ipmData++;
>-				*pmData++ = *ipmData++;
>-			    */
>-	                        pixel = XGetPixel(ximage_ipm,dst_x+x1,dst_y+y1) ;
>-                                XPutPixel(ximage,dst_x+x1, dst_y+y1,pixel);
>-			if(!test){
>-			   test = 1 ;
>-			}
>-			    }
>-			    /*
>-			    else {
>-				pmData +=3;
>-				ipmData +=3;
>-			    }
>-			    */
>-			}
>-		    }
>-		}
>-	}
>-        XDestroyImage (image);
>-      }	/* end of src_in_overlay */
>-    } /** end transparency **/
>-    destroy_region_list( vis_regions);
>-    if (vis_image_regions) destroy_region_list( vis_image_regions );
>-    FreeXVisualInfo(pVisuals, pOverlayVisuals, pImageVisuals);
>-    XSync(disp, 0);
>-
>-    return ximage;
>-}
>-
>-/** ------------------------------------------------------------------------
>-	Creates a list of the subwindows of a given window which have a
>-	different visual than their parents.  The function is recursive.
>-	This list is used in make_region_list(), which coalesces the
>-	windows with the same visual into a region.
>-	image_wins must point to an existing list struct that's already
>-	been zeroed (zero_list()).
>-    ------------------------------------------------------------------------ **/
>-static void make_src_list( disp, image_wins, bbox, curr, x_rootrel, y_rootrel, 
>-		    curr_attrs, pclip)
>-    Display		*disp;
>-    list_ptr		image_wins;
>-    XRectangle		*bbox;			/* bnding box of area we want */
>-    Window		curr;
>-    int			x_rootrel;		/* pos of curr WRT root */
>-    int			y_rootrel;
>-    XWindowAttributes	*curr_attrs;
>-    XRectangle		*pclip;			/* visible part of curr, not */
>-						/* obscurred by ancestors */
>-{
>-    XWindowAttributes child_attrs;
>-    Window root, parent, *child;	/* variables for XQueryTree() */
>-    Window *save_child_list;		/* variables for XQueryTree() */
>-    unsigned int nchild;		/* variables for XQueryTree() */
>-    XRectangle child_clip;		/* vis part of child */
>-    int curr_clipX, curr_clipY, curr_clipRt, curr_clipBt;
>-
>-    /* check that win is mapped & not outside bounding box */
>-    if (curr_attrs->map_state == IsViewable &&
>-	curr_attrs->class == InputOutput &&
>-	!( pclip->x >= (int) (bbox->x + bbox->width)	||
>-	   pclip->y >= (int) (bbox->y + bbox->height)	||
>-	   (int) (pclip->x + pclip->width)  <= bbox->x	||
>-	   (int) (pclip->y + pclip->height) <= bbox->y)) {
>-
>-	XQueryTree( disp, curr, &root, &parent, &child, &nchild );
>-	save_child_list = child;      /* so we can free list when we're done */
>-	add_window_to_list( image_wins, curr, x_rootrel, y_rootrel, 
>-			    pclip->x, pclip->y, 
>-			    pclip->width, pclip->height, 
>-			    curr_attrs->border_width,curr_attrs->visual, 
>-			    curr_attrs->colormap, parent);
>-
>-	
>-/** ------------------------------------------------------------------------
>-	set RR coords of right (Rt), left (X), bottom (Bt) and top (Y)
>-	of rect we clip all children by.  This is our own clip rect (pclip)
>-	inflicted on us by our parent plus our own borders.  Within the
>-	child loop, we figure the clip rect for each child by adding in
>-	it's rectangle (not taking into account the child's borders).
>-    ------------------------------------------------------------------------ **/
>-	curr_clipX = MAX( pclip->x, x_rootrel + (int) curr_attrs->border_width);
>-	curr_clipY = MAX( pclip->y, y_rootrel + (int) curr_attrs->border_width);
>-	curr_clipRt = MIN( pclip->x + (int) pclip->width,
>-			   x_rootrel + (int) curr_attrs->width + 
>-			   2 * (int) curr_attrs->border_width);
>-	curr_clipBt = MIN( pclip->y + (int) pclip->height,
>-			   y_rootrel + (int) curr_attrs->height + 
>-			   2 * (int) curr_attrs->border_width);
>-
>-	while (nchild--) {
>-	    int new_width, new_height;
>-	    int child_xrr, child_yrr;	/* root relative x & y of child */
>-
>-	    XGetWindowAttributes( disp, *child, &child_attrs);
>-
>-	    /* intersect parent & child clip rects */
>-	    child_xrr = x_rootrel + child_attrs.x + curr_attrs->border_width;
>-	    child_clip.x = MAX( curr_clipX, child_xrr);
>-	    new_width = MIN( curr_clipRt, child_xrr + (int) child_attrs.width
>-			     + 2 * child_attrs.border_width)
>-			- child_clip.x;
>-	    if (new_width >= 0) {
>-		child_clip.width = new_width;
>-
>-		child_yrr = y_rootrel + child_attrs.y + 
>-			    curr_attrs->border_width;
>-		child_clip.y = MAX( curr_clipY, child_yrr);
>-		new_height = MIN( curr_clipBt, 
>-				  child_yrr + (int) child_attrs.height + 
>-				      2 * child_attrs.border_width) 
>-			     - child_clip.y;
>-		if (new_height >= 0) {
>-		    child_clip.height = new_height;
>-		    make_src_list( disp, image_wins, bbox, *child, 
>-				   child_xrr, child_yrr, 
>-				   &child_attrs, &child_clip);
>-		}
>-	    }
>-	    child++;
>-	}
>-	XFree( save_child_list);
>-    }
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	This function creates a list of regions which tile a specified
>-	window.  Each region contains all visible portions of the window
>-	which are drawn with the same visual.  For example, if the
>-	window consists of subwindows of two different visual types,
>-	there will be two regions in the list.  
>-	Returns a pointer to the list.
>-    ------------------------------------------------------------------------ **/
>-static list_ptr make_region_list( disp, win, bbox, hasNonDefault, 
>-			     numImageVisuals, pImageVisuals, allImage)
>-    Display 		*disp;
>-    Window 		win;
>-    XRectangle 		*bbox;
>-    int 		*hasNonDefault;
>-    int			numImageVisuals;
>-    XVisualInfo		**pImageVisuals;
>-    int			*allImage;
>-{
>-    XWindowAttributes	win_attrs;
>-    list		image_wins;
>-    list_ptr		image_regions;
>-    list_ptr		srcs_left;
>-    image_region_type	*new_reg;
>-    image_win_type	*base_src, *src;
>-    Region		bbox_region = XCreateRegion();
>-    XRectangle		clip;
>-    int			image_only;
>-
>-    int                 count=0 ; 
>-    
>-    *hasNonDefault = False;
>-    XUnionRectWithRegion( bbox, bbox_region, bbox_region);
>-    XGetWindowAttributes( disp, win, &win_attrs);
>-
>-    zero_list( &image_wins);
>-    clip.x = 0;
>-    clip.y = 0;
>-    clip.width  = win_attrs.width;
>-    clip.height = win_attrs.height;
>-    make_src_list( disp, &image_wins, bbox, win, 
>-		   0 /* x_rootrel */, 0 /* y_rootrel */, &win_attrs, &clip);
>-
>-    image_regions = new_list();
>-    image_only = (*allImage) ? True:False; 
>-
>-    for (base_src = (image_win_type *) first_in_list( &image_wins); base_src;
>-	 base_src = (image_win_type *) next_in_list( &image_wins)) 
>-    {
>-	/* test for image visual */
>-	if (!image_only || src_in_image(base_src, numImageVisuals, pImageVisuals))
>-	{
>-	    /* find a window whose visual hasn't been put in list yet */
>-	    if (!src_in_region_list( base_src, image_regions))
>-	    {
>-		if (! (new_reg = (image_region_type *) 
>-					malloc( sizeof( image_region_type)))) {
>-		    return (list_ptr) NULL;
>-		}
>-		count++;  
>-		
>-		new_reg->visible_region = XCreateRegion();
>-		new_reg->win		= base_src->win;
>-		new_reg->vis		= base_src->vis;
>-		new_reg->cmap	 	= base_src->cmap;
>-		new_reg->x_rootrel	= base_src->x_rootrel;
>-		new_reg->y_rootrel	= base_src->y_rootrel;
>-		new_reg->x_vis		= base_src->x_vis;
>-		new_reg->y_vis		= base_src->y_vis;
>-		new_reg->width		= base_src->width;
>-		new_reg->height		= base_src->height;
>-		new_reg->border		= base_src->border_width;
>-		
>-		srcs_left = (list_ptr) dup_list_head( &image_wins, START_AT_CURR);
>-		for (src = (image_win_type *) first_in_list( srcs_left); src;
>-		     src = (image_win_type *) next_in_list( srcs_left)) {
>-		    if (SAME_REGIONS( base_src, src)) {
>-			add_rect_to_image_region( new_reg, src->x_vis, src->y_vis, 
>-						  src->width, src->height);
>-		    }
>-		    else {
>-			if (!image_only || src_in_image(src, numImageVisuals, pImageVisuals))
>-			{ 
>-			    subtr_rect_from_image_region( new_reg, src->x_vis,
>-					  src->y_vis, src->width, src->height);
>-			} 
>-		    }
>-		}
>-		XIntersectRegion( bbox_region, new_reg->visible_region, 
>-				  new_reg->visible_region);
>-		if (! XEmptyRegion( new_reg->visible_region)) {
>-		    add_to_list( image_regions, new_reg);
>-		    if (new_reg->vis != DefaultVisualOfScreen( win_attrs.screen) ||
>-			new_reg->cmap != DefaultColormapOfScreen( 
>-							    win_attrs.screen)) {
>-			*hasNonDefault = True;
>-		    }
>-		}
>-		else {
>-		    XDestroyRegion( new_reg->visible_region);
>-		    free( (void *) new_reg);
>-		}
>-	    }
>-	} else *allImage = 0;
>-    }
>-    delete_list( &image_wins, True);
>-    XDestroyRegion( bbox_region);
>-    return image_regions;
>-}
>-/** ------------------------------------------------------------------------
>-	Destructor called from destroy_region_list().
>-    ------------------------------------------------------------------------ **/
>-void destroy_image_region( image_region)
>-    image_region_type *image_region;
>-{
>-    XDestroyRegion( image_region->visible_region);
>-    free( (void *) image_region);
>-}
>-
>-/** ------------------------------------------------------------------------
>-	Destroys the region list, destroying all the regions contained in it.
>-    ------------------------------------------------------------------------ **/
>-static void destroy_region_list( rlist)
>-    list_ptr rlist;
>-{
>-    delete_list_destroying( rlist, (DESTRUCT_FUNC_PTR)destroy_image_region);
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Subtracts the specified rectangle from the region in image_region.
>-	First converts the rectangle to a region of its own, since X
>-	only provides a way to subtract one region from another, not a
>-	rectangle from a region.
>-    ------------------------------------------------------------------------ **/
>-static void subtr_rect_from_image_region( image_region, x, y, width, height)
>-    image_region_type *image_region;
>-    int x;
>-    int y;
>-    int width;
>-    int height;
>-{
>-    XRectangle rect;
>-    Region rect_region;
>-
>-    rect_region = XCreateRegion();
>-    rect.x = x;
>-    rect.y = y;
>-    rect.width = width;
>-    rect.height = height;
>-    XUnionRectWithRegion( &rect, rect_region, rect_region);
>-    XSubtractRegion( image_region->visible_region, rect_region, 
>-		     image_region->visible_region);
>-    XDestroyRegion( rect_region);
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Adds the specified rectangle to the region in image_region.
>-    ------------------------------------------------------------------------ **/
>-static void add_rect_to_image_region( image_region, x, y, width, height)
>-    image_region_type *image_region;
>-    int x;
>-    int y;
>-    int width;
>-    int height;
>-{
>-    XRectangle rect;
>-
>-    rect.x = x;
>-    rect.y = y;
>-    rect.width = width;
>-    rect.height = height;
>-    XUnionRectWithRegion( &rect, image_region->visible_region, 
>-			  image_region->visible_region);
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Returns TRUE if the given src's visual is already represented in
>-	the image_regions list, FALSE otherwise.
>-    ------------------------------------------------------------------------ **/
>-static int src_in_region_list( src, image_regions)
>-    image_win_type *src;
>-    list_ptr image_regions;
>-{
>-    image_region_type	*ir;
>-
>-    for (ir = (image_region_type *) first_in_list( image_regions); ir;
>-	 ir = (image_region_type *) next_in_list( image_regions)) {
>-	if (SAME_REGIONS( ir, src)) {
>-
>-	    return 1;
>-	}
>-    }
>-
>-    return 0;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Makes a new entry in image_wins with the given fields filled in.
>-    ------------------------------------------------------------------------ **/
>-static void add_window_to_list( image_wins, w, xrr, yrr, x_vis, y_vis, 
>-				width, height, border_width,vis, cmap, parent)
>-    list_ptr	image_wins;
>-    Window	w;
>-    int		xrr;
>-    int 	yrr;
>-    int		x_vis;
>-    int 	y_vis;
>-    int 	width;
>-    int 	height;
>-    Visual	*vis;
>-    Colormap	cmap;
>-    Window	parent;
>-{
>-    image_win_type	*new_src;
>-
>-    if ((new_src = (image_win_type *) malloc( sizeof( image_win_type))) == NULL)
>-
>-	return;
>-
>-    new_src->win = w;
>-    new_src->x_rootrel = xrr;
>-    new_src->y_rootrel = yrr;
>-    new_src->x_vis = x_vis;
>-    new_src->y_vis = y_vis;
>-    new_src->width = width;
>-    new_src->height = height;
>-    new_src->border_width = border_width;
>-    new_src->vis = vis;
>-    new_src->cmap = cmap;
>-    new_src->parent = parent;
>-    add_to_list( image_wins, new_src);
>-}
>-
>-/** ------------------------------------------------------------------------
>-	Returns TRUE if the given src's visual is in the image planes,
>-	FALSE otherwise.
>-    ------------------------------------------------------------------------ **/
>-static int src_in_image( src, numImageVisuals, pImageVisuals)
>-    image_win_type 	*src;
>-    int			numImageVisuals;
>-    XVisualInfo		**pImageVisuals;
>-{
>-    int 		i;
>-
>-    for (i = 0 ; i < numImageVisuals ; i++)
>-    {
>-	if (pImageVisuals[i]->visual == src->vis)
>-	    return 1;
>-    }
>-    return 0;
>-}
>-
>-
>-/** ------------------------------------------------------------------------
>-	Returns TRUE if the given src's visual is in the overlay planes
>-	and transparency is possible, FALSE otherwise.
>-    ------------------------------------------------------------------------ **/
>-static int src_in_overlay( src, numOverlayVisuals, pOverlayVisuals, 
>-			transparentColor, transparentType)
>-    image_region_type 	*src;
>-    int			numOverlayVisuals;
>-    OverlayInfo         *pOverlayVisuals;
>-    int			*transparentColor;
>-    int			*transparentType;
>-{
>-    int 		i;
>-
>-    for (i = 0 ; i < numOverlayVisuals ; i++)
>-    {
>-	if (((pOverlayVisuals[i].pOverlayVisualInfo)->visual == src->vis)
>-		&& (pOverlayVisuals[i].transparentType != None))
>-	{
>-	    *transparentColor = pOverlayVisuals[i].value;
>-	    *transparentType = pOverlayVisuals[i].transparentType;
>-	    return 1;
>-	}
>-	
>-	else {
>-	}
>-	
>-    }
>-    return 0;
>-}
>-
>-
>-/********************** from wsutils.c ******************************/
>-
>-/******************************************************************************
>- *
>- * This file contains a set of example utility procedures; procedures that can
>- * help a "window-smart" Starbase or PHIGS program determine information about
>- * a device, and create image and overlay plane windows.  To use these
>- * utilities, #include "wsutils.h" and compile this file and link the results
>- * with your program.
>- *
>- ******************************************************************************/
>-
>-
>-
>-#define STATIC_GRAY	0x01
>-#define GRAY_SCALE	0x02
>-#define PSEUDO_COLOR	0x04
>-#define TRUE_COLOR	0x10
>-#define DIRECT_COLOR	0x11
>-
>-
>-static int	weCreateServerOverlayVisualsProperty = False;
>-
>-
>-/******************************************************************************
>- *
>- * GetXVisualInfo()
>- *
>- * This routine takes an X11 Display, screen number, and returns whether the
>- * screen supports transparent overlays and three arrays:
>- *
>- *	1) All of the XVisualInfo struct's for the screen.
>- *	2) All of the OverlayInfo struct's for the screen.
>- *	3) An array of pointers to the screen's image plane XVisualInfo
>- *	   structs.
>- *
>- * The code below obtains the array of all the screen's visuals, and obtains
>- * the array of all the screen's overlay visual information.  It then processes
>- * the array of the screen's visuals, determining whether the visual is an
>- * overlay or image visual.
>- *
>- * If the routine sucessfully obtained the visual information, it returns zero.
>- * If the routine didn't obtain the visual information, it returns non-zero.
>- *
>- ******************************************************************************/
>-
>-int GetXVisualInfo(display, screen, transparentOverlays,
>-		   numVisuals, pVisuals,
>-		   numOverlayVisuals, pOverlayVisuals,
>-		   numImageVisuals, pImageVisuals)
>-
>-    Display	*display;		/* Which X server (aka "display"). */
>-    int		screen;			/* Which screen of the "display". */
>-    int		*transparentOverlays;	/* Non-zero if there's at least one
>-					 * overlay visual and if at least one
>-					 * of those supports a transparent
>-					 * pixel. */
>-    int		*numVisuals;		/* Number of XVisualInfo struct's
>-					 * pointed to to by pVisuals. */
>-    XVisualInfo	**pVisuals;		/* All of the device's visuals. */
>-    int		*numOverlayVisuals;	/* Number of OverlayInfo's pointed
>-					 * to by pOverlayVisuals.  If this
>-					 * number is zero, the device does
>-					 * not have overlay planes. */
>-    OverlayInfo	**pOverlayVisuals;	/* The device's overlay plane visual
>-					 * information. */
>-    int		*numImageVisuals;	/* Number of XVisualInfo's pointed
>-					 * to by pImageVisuals. */
>-    XVisualInfo	***pImageVisuals;	/* The device's image visuals. */
>-{
>-    XVisualInfo	getVisInfo;		/* Paramters of XGetVisualInfo */
>-    int		mask;
>-    XVisualInfo	*pVis, **pIVis;		/* Faster, local copies */
>-    OverlayInfo	*pOVis;
>-    OverlayVisualPropertyRec	*pOOldVis;
>-    int		nVisuals, nOVisuals;
>-    Atom	overlayVisualsAtom;	/* Parameters for XGetWindowProperty */
>-    Atom	actualType;
>-    unsigned long numLongs, bytesAfter;
>-    int		actualFormat; 
>-    int		nImageVisualsAlloced;	/* Values to process the XVisualInfo */
>-    int		imageVisual;		/* array */
>-
>-
>-    /* First, get the list of visuals for this screen. */
>-    getVisInfo.screen = screen;
>-    mask = VisualScreenMask; 
>-
>-    *pVisuals = XGetVisualInfo(display, mask, &getVisInfo, numVisuals);
>-    if ((nVisuals = *numVisuals) <= 0)
>-    {
>-	/* Return that the information wasn't sucessfully obtained: */
>-	return(1);
>-    }
>-    pVis = *pVisuals;
>-
>-
>-    /* Now, get the overlay visual information for this screen.  To obtain
>-     * this information, get the SERVER_OVERLAY_VISUALS property.
>-     */
>-    overlayVisualsAtom = XInternAtom(display, "SERVER_OVERLAY_VISUALS", True);
>-    if (overlayVisualsAtom != None)
>-    {
>-	/* Since the Atom exists, we can request the property's contents.  The
>-	 * do-while loop makes sure we get the entire list from the X server.
>-	 */
>-	bytesAfter = 0;
>-	numLongs = sizeof(OverlayVisualPropertyRec) / 4;
>-	do
>-	{
>-	    numLongs += bytesAfter * 4;
>-	    XGetWindowProperty(display, RootWindow(display, screen),
>-			       overlayVisualsAtom, 0, numLongs, False,
>-			       overlayVisualsAtom, &actualType, &actualFormat,
>-			       &numLongs, &bytesAfter, (unsigned char**) pOverlayVisuals);
>-	} while (bytesAfter > 0);
>-
>-
>-	/* Calculate the number of overlay visuals in the list. */
>-	*numOverlayVisuals = numLongs / (sizeof(OverlayVisualPropertyRec) / 4);
>-    }
>-    else
>-    {
>-	/* This screen doesn't have overlay planes. */
>-	*numOverlayVisuals = 0;
>-	*pOverlayVisuals = NULL;
>-	*transparentOverlays = 0;
>-    }
>-
>-
>-    /* Process the pVisuals array. */
>-    *numImageVisuals = 0;
>-    nImageVisualsAlloced = 1;
>-    pIVis = *pImageVisuals = (XVisualInfo **) malloc(sizeof(XVisualInfo *));
>-    while (--nVisuals >= 0)
>-    {
>-	nOVisuals = *numOverlayVisuals;
>-	pOVis = *pOverlayVisuals;
>-	imageVisual = True;
>-	while (--nOVisuals >= 0)
>-	{
>-	    pOOldVis = (OverlayVisualPropertyRec *) pOVis;
>-	    if (pVis->visualid == pOOldVis->visualID)
>-	    {
>-		imageVisual = False;
>-		pOVis->pOverlayVisualInfo = pVis;
>-		if (pOVis->transparentType == TransparentPixel)
>-		    *transparentOverlays = 1;
>-	    }
>-	    pOVis++;
>-	}
>-	if (imageVisual)
>-	{
>-	    if ((*numImageVisuals += 1) > nImageVisualsAlloced)
>-	    {
>-		nImageVisualsAlloced++;
>-		*pImageVisuals = (XVisualInfo **)
>-		    realloc(*pImageVisuals, (nImageVisualsAlloced * sizeof(XVisualInfo *)));
>-		pIVis = *pImageVisuals + (*numImageVisuals - 1);
>-	    }
>-	    *pIVis++ = pVis;
>-	}
>-	pVis++;
>-    }
>-
>-
>-    /* Return that the information was sucessfully obtained: */
>-    return(0);
>-
>-} /* GetXVisualInfo() */
>-
>-
>-/******************************************************************************
>- *
>- * FreeXVisualInfo()
>- *
>- * This routine frees the data that was allocated by GetXVisualInfo().
>- *
>- ******************************************************************************/
>-
>-void FreeXVisualInfo(pVisuals, pOverlayVisuals, pImageVisuals)
>-
>-    XVisualInfo	*pVisuals;
>-    OverlayInfo	*pOverlayVisuals;
>-    XVisualInfo	**pImageVisuals;
>-{
>-    XFree(pVisuals);
>-    if (weCreateServerOverlayVisualsProperty)
>-	free(pOverlayVisuals);
>-    else
>-	XFree(pOverlayVisuals);
>-    free(pImageVisuals);
>-
>-} /* FreeXVisualInfo() */
>Index: xc/programs/xwd/multiVis.h
>===================================================================
>RCS file: xc/programs/xwd/multiVis.h
>diff -N xc/programs/xwd/multiVis.h
>--- xc/programs/xwd/multiVis.h	28 May 2002 01:50:57 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,60 +0,0 @@
>-/* $Xorg: multiVis.h,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
>-/** ------------------------------------------------------------------------
>-	This file contains routines for manipulating generic lists.
>-	Lists are implemented with a "harness".  In other words, each
>-	node in the list consists of two pointers, one to the data item
>-	and one to the next node in the list.  The head of the list is
>-	the same struct as each node, but the "item" ptr is used to point
>-	to the current member of the list (used by the first_in_list and
>-	next_in_list functions).
>-
>-Copyright 1994 Hewlett-Packard Co.
>-Copyright 1996, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>- ------------------------------------------------------------------------ **/
>-
>-extern int GetMultiVisualRegions(
>-#if NeedFunctionPrototypes
>-    Display *, Window, int, int, unsigned int,
>-    unsigned int, int *, int *, XVisualInfo **, int *,
>-    OverlayInfo  **, int *, XVisualInfo ***, list_ptr *,
>-    list_ptr *, int *
>-#endif
>-); 
>-
>-extern XImage *ReadAreaToImage(
>-#if NeedFunctionPrototypes
>-    Display *, Window, int, int, unsigned int,
>-    unsigned int, int, XVisualInfo *, int,
>-    OverlayInfo	*, int, XVisualInfo **, list_ptr,
>-    list_ptr, int, int
>-#endif
>-);
>-
>-extern void initFakeVisual(
>-#if NeedFunctionPrototypes
>-    Visual *
>-#endif
>-);
>Index: xc/programs/xwd/wsutils.h
>===================================================================
>RCS file: xc/programs/xwd/wsutils.h
>diff -N xc/programs/xwd/wsutils.h
>--- xc/programs/xwd/wsutils.h	28 May 2002 01:50:58 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,350 +0,0 @@
>-/* $Xorg: wsutils.h,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
>-/** ------------------------------------------------------------------------
>-	This file contains routines for manipulating generic lists.
>-	Lists are implemented with a "harness".  In other words, each
>-	node in the list consists of two pointers, one to the data item
>-	and one to the next node in the list.  The head of the list is
>-	the same struct as each node, but the "item" ptr is used to point
>-	to the current member of the list (used by the first_in_list and
>-	next_in_list functions).
>-
>-Copyright 1994 Hewlett-Packard Co.
>-Copyright 1996, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>-    ------------------------------------------------------------------------ **/
>-/******************************************************************************
>- *
>- * This file contains various typedef's, macros and procedure declarations for
>- * a set of example utility procedures contained in the file "wsutils.c".
>- *
>- ******************************************************************************/
>-
>-/* This is the actual structure returned by the X server describing the
>- * SERVER_OVERLAY_VISUAL property.
>- */
>-typedef struct
>-{
>-  VisualID	visualID;		/* The VisualID of the overlay visual */
>-  int		transparentType;	/* Can be None, TransparentPixel or
>-					 * TransparentMask */
>-  int		value;			/* Pixel value */
>-  int		layer;			/* Overlay planes will always be in
>-					 * layer 1 */
>-} OverlayVisualPropertyRec;
>-
>-
>-/* This is structure also describes the SERVER_OVERLAY_VISUAL property, but
>- * should be more useful than the one actually returned by the X server
>- * because it actually points to the visual's XVisualInfo struct rather than
>- * refering to the visual's ID.
>- */
>-typedef struct
>-{
>-  XVisualInfo	*pOverlayVisualInfo;	/* Pointer to the XVisualInfo struct */
>-  int		transparentType;	/* Can be None, TransparentPixel or
>-					 * TransparentMask */
>-  int		value;			/* Pixel value */
>-  int		layer;			/* Overlay planes will always be in
>-					 * layer 1 */
>-} OverlayInfo;
>-
>-
>-/* These macros are the values of the "transparentType" above: */
>-#ifndef None
>-#define None 0
>-#endif
>-#ifndef TransparentPixel
>-#define TransparentPixel	1
>-#endif
>-
>-
>-/* These macros define how flexible a program is when it requests a window's
>- * creation with either the CreateImagePlanesWindow() or
>- * CreateOverlayPlanesWindow():
>- */
>-#ifndef NOT_FLEXIBLE
>-#define NOT_FLEXIBLE		0
>-#define FLEXIBLE		1
>-#endif
>-
>-
>-/* These macros define the values of the "sbCmapHint" parameter of the
>- * CreateImagePlanesWindow():
>- */
>-#ifndef SB_CMAP_TYPE_NORMAL
>-#define SB_CMAP_TYPE_NORMAL	1
>-#endif
>-
>-#ifndef SB_CMAP_TYPE_MONOTONIC
>-#define SB_CMAP_TYPE_MONOTONIC	2
>-#endif
>-
>-#ifndef SB_CMAP_TYPE_FULL
>-#define SB_CMAP_TYPE_FULL	4
>-#endif
>-
>-
>-/******************************************************************************
>- *
>- * GetXVisualInfo()
>- *
>- * This routine takes an X11 Display, screen number, and returns whether the
>- * screen supports transparent overlays and three arrays:
>- *
>- *	1) All of the XVisualInfo struct's for the screen.
>- *	2) All of the OverlayInfo struct's for the screen.
>- *	3) An array of pointers to the screen's image plane XVisualInfo
>- *	   structs.
>- *
>- * The code below obtains the array of all the screen's visuals, and obtains
>- * the array of all the screen's overlay visual information.  It then processes
>- * the array of the screen's visuals, determining whether the visual is an
>- * overlay or image visual.
>- *
>- * If the routine sucessfully obtained the visual information, it returns zero.
>- * If the routine didn't obtain the visual information, it returns non-zero.
>- *
>- ******************************************************************************/
>-
>-extern int GetXVisualInfo(
>-#if NeedFunctionPrototypes
>-    Display	*display,		/* Which X server (aka "display"). */
>-    int		screen,			/* Which screen of the "display". */
>-    int		*transparentOverlays,	/* Non-zero if there's at least one
>-					 * overlay visual and if at least one
>-					 * of those supports a transparent
>-					 * pixel. */
>-    int		*numVisuals,		/* Number of XVisualInfo struct's
>-					 * pointed to to by pVisuals. */
>-    XVisualInfo	**pVisuals,		/* All of the device's visuals. */
>-    int		*numOverlayVisuals,	/* Number of OverlayInfo's pointed
>-					 * to by pOverlayVisuals.  If this
>-					 * number is zero, the device does
>-					 * not have overlay planes. */
>-    OverlayInfo	**pOverlayVisuals,	/* The device's overlay plane visual
>-					 * information. */
>-    int		*numImageVisuals,	/* Number of XVisualInfo's pointed
>-					 * to by pImageVisuals. */
>-    XVisualInfo	***pImageVisuals	/* The device's image visuals. */
>-#endif
>-		    );
>-
>-
>-/******************************************************************************
>- *
>- * FreeXVisualInfo()
>- *
>- * This routine frees the data that was allocated by GetXVisualInfo().
>- *
>- ******************************************************************************/
>-
>-extern void FreeXVisualInfo(
>-#if NeedFunctionPrototypes
>-    XVisualInfo	*pVisuals,
>-    OverlayInfo	*pOverlayVisuals,
>-    XVisualInfo	**pImageVisuals
>-#endif
>-		     );
>-
>-
>-/******************************************************************************
>- *
>- * FindImagePlanesVisual()
>- *
>- * This routine attempts to find a visual to use to create an image planes
>- * window based upon the information passed in.
>- *
>- * The "Hint" values give guides to the routine as to what the program wants.
>- * The "depthFlexibility" value tells the routine how much the program wants
>- * the actual "depthHint" specified.  If the program can't live with the
>- * screen's image planes visuals, the routine returns non-zero, and the
>- * "depthObtained" and "pImageVisualToUse" return parameters are NOT valid.
>- * Otherwise, the "depthObtained" and "pImageVisualToUse" return parameters
>- * are valid and the routine returns zero.
>- *
>- * NOTE: This is just an example of what can be done.  It may or may not be
>- * useful for any specific application.
>- *
>- ******************************************************************************/
>-
>-extern int FindImagePlanesVisual(
>-#if NeedFunctionPrototypes
>-    Display	*display,		/* Which X server (aka "display"). */
>-    int		screen,			/* Which screen of the "display". */
>-    int		numImageVisuals,	/* Number of XVisualInfo's pointed
>-					 * to by pImageVisuals. */
>-    XVisualInfo	**pImageVisuals,	/* The device's image visuals. */
>-    int		sbCmapHint,		/* What Starbase cmap modes will be
>-					 * used with the visual.  NOTE: This
>-					 * is a mask of the possible values. */
>-    int		depthHint,		/* Desired depth. */
>-    int		depthFlexibility,	/* How much the actual value in
>-					 * "depthHint" is desired. */
>-    Visual	**pImageVisualToUse,	/* The screen's image visual to use. */
>-    int		*depthObtained		/* Actual depth of the visual. */
>-#endif
>-				     );
>-
>-
>-/******************************************************************************
>- *
>- * FindOverlayPlanesVisual()
>- *
>- * This routine attempts to find a visual to use to create an overlay planes
>- * window based upon the information passed in.
>- *
>- * While the CreateImagePlanesWindow() routine took a sbCmapHint, this
>- * routine doesn't.  Starbase's CMAP_FULL shouldn't be used in overlay planes
>- * windows.  This is partially because this functionality is better suited in
>- * the image planes where there are generally more planes, and partially
>- * because the overlay planes generally have PseudoColor visuals with one
>- * color being transparent (the transparent normally being the "white" color
>- * for CMAP_FULL).
>- *
>- * The "depthHint" values give guides to the routine as to what depth the
>- * program wants the window to be.  The "depthFlexibility" value tells the
>- * routine how much the program wants the actual "depthHint" specified.  If
>- * the program can't live with the screen's overlay planes visuals, the
>- * routine returns non-zero, and the "depthObtained" and "pOverlayVisualToUse"
>- * return parameters are NOT valid.  Otherwise, the "depthObtained" and
>- * "pOverlayVisualToUse" return parameters are valid and the routine returns
>- * zero.
>- *
>- * NOTE: This is just an example of what can be done.  It may or may not be
>- * useful for any specific application.
>- *
>- ******************************************************************************/
>-
>-extern int FindOverlayPlanesVisual(
>-#if NeedFunctionPrototypes
>-    Display	*display,		/* Which X server (aka "display"). */
>-    int		screen,			/* Which screen of the "display". */
>-    int		numOverlayVisuals,	/* Number of OverlayInfo's pointed
>-					 * to by pOverlayVisuals. */
>-    OverlayInfo	*pOverlayVisuals,	/* The device's overlay plane visual
>-					 * information. */
>-    int		depthHint,		/* Desired depth. */
>-    int		depthFlexibility,	/* How much the actual value in
>-					 * "depthHint" is desired. */
>-    int		transparentBackground,	/* Non-zero if the visual must have
>-					 * a transparent color. */
>-    Visual	**pOverlayVisualToUse,	/* The screen's overlay visual to
>-					 * use. */
>-    int		*depthObtained,		/* Actual depth of the visual. */
>-    int		*transparentColor	/* The transparent color the program
>-					 * can use with the visual. */
>-#endif
>-				);
>-
>-
>-/******************************************************************************
>- *
>- * CreateImagePlanesWindow()
>- *
>- * This routine creates an image planes window, potentially creates a colormap
>- * for the window to use, and sets the window's standard properties, based
>- * upon the information passed in to the routine.  While "created," the window
>- * has not been mapped.
>- *
>- * If the routine suceeds, it returns zero and the return parameters
>- * "imageWindow", "imageColormap" and "mustFreeImageColormap" are valid.
>- * Otherwise, the routine returns non-zero and the return parameters are
>- * NOT valid.
>- *
>- * NOTE: This is just an example of what can be done.  It may or may not be
>- * useful for any specific application.
>- *
>- ******************************************************************************/
>-
>-extern int CreateImagePlanesWindow(
>-#if NeedFunctionPrototypes
>-    Display	*display,		/* Which X server (aka "display"). */
>-    int		screen,			/* Which screen of the "display". */
>-    Window	parentWindow,		/* Window ID of the parent window for
>-					 * the created window. */
>-    int		windowX,		/* Desired X coord. of the window. */
>-    int		windowY,		/* Desired Y coord of the window. */
>-    int		windowWidth,		/* Desired width of the window. */
>-    int		windowHeight,		/* Desired height of the window. */
>-    int		windowDepth,		/* Desired depth of the window. */
>-    Visual	*pImageVisualToUse,	/* The window's image planes visual. */
>-    int		argc,			/* Program's argc parameter. */
>-    char	*argv[],		/* Program's argv parameter. */
>-    char	*windowName,		/* Name to put on window's border. */
>-    char	*iconName,		/* Name to put on window's icon. */
>-    Window	*imageWindow,		/* Window ID of the created window. */
>-    Colormap	*imageColormap,		/* The window's colormap. */
>-    int		*mustFreeImageColormap	/* Non-zero if the program must call
>-					 * XFreeColormap() for imageColormap. */
>-#endif
>-				);
>-
>-
>-/******************************************************************************
>- *
>- * CreateOverlayPlanesWindow()
>- *
>- * This routine creates an overlay planes window, potentially creates a colormap
>- * for the window to use, and sets the window's standard properties, based
>- * upon the information passed in to the routine.  While "created," the window
>- * has not been mapped.
>- *
>- * If the routine suceeds, it returns zero and the return parameters
>- * "overlayWindow", "overlayColormap" and "mustFreeOverlayColormap" are valid.
>- * Otherwise, the routine returns non-zero and the return parameters are
>- * NOT valid.
>- *
>- * NOTE: This is just an example of what can be done.  It may or may not be
>- * useful for any specific application.
>- *
>- ******************************************************************************/
>-
>-int CreateOverlayPlanesWindow(
>-#if NeedFunctionPrototypes
>-    Display	*display,		/* Which X server (aka "display"). */
>-    int		screen,			/* Which screen of the "display". */
>-    Window	parentWindow,		/* Window ID of the parent window for
>-					 * the created window. */
>-    int		windowX,		/* Desired X coord. of the window. */
>-    int		windowY,		/* Desired Y coord of the window. */
>-    int		windowWidth,		/* Desired width of the window. */
>-    int		windowHeight,		/* Desired height of the window. */
>-    int		windowDepth,		/* Desired depth of the window. */
>-    Visual	*pOverlayVisualToUse,	/* The window's overlay planes visual.*/
>-    int		argc,			/* Program's argc parameter. */
>-    char	*argv[],		/* Program's argv parameter. */
>-    char	*windowName,		/* Name to put on window's border. */
>-    char	*iconName,		/* Name to put on window's icon. */
>-    int		transparentBackground,	/* Non-zero if the window's background
>-					 * should be a transparent color. */
>-    int		*transparentColor,	/* The transparent color to use as the
>-					 * window's background. */
>-    Window	*overlayWindow,		/* Window ID of the created window. */
>-    Colormap	*overlayColormap,	/* The window's colormap. */
>-    int		*mustFreeOverlayColormap/* Non-zero if the program must call
>-					  * XFreeColormap() for
>-					  * overlayColormap. */
>-#endif
>-				);
>Index: xc/programs/xwd/xwd.c
>===================================================================
>RCS file: xc/programs/xwd/xwd.c
>diff -N xc/programs/xwd/xwd.c
>--- xc/programs/xwd/xwd.c	28 May 2002 01:50:58 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,664 +0,0 @@
>-/* $Xorg: xwd.c,v 1.5 2001/02/09 02:06:03 xorgcvs Exp $ */
>-
>-/*
>-
>-Copyright 1987, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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
>-OPEN GROUP 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 of The Open Group shall not be
>-used in advertising or otherwise to promote the sale, use or other dealings
>-in this Software without prior written authorization from The Open Group.
>-
>-*/
>-
>-/*
>- * xwd.c MIT Project Athena, X Window system window raster image dumper.
>- *
>- * This program will dump a raster image of the contents of a window into a 
>- * file for output on graphics printers or for other uses.
>- *
>- *  Author:	Tony Della Fera, DEC
>- *		17-Jun-85
>- * 
>- *  Modification history:
>- *
>- *  11/14/86 Bill Wyatt, Smithsonian Astrophysical Observatory
>- *    - Removed Z format option, changing it to an XY option. Monochrome 
>- *      windows will always dump in XY format. Color windows will dump
>- *      in Z format by default, but can be dumped in XY format with the
>- *      -xy option.
>- *
>- *  11/18/86 Bill Wyatt
>- *    - VERSION 6 is same as version 5 for monchrome. For colors, the 
>- *      appropriate number of Color structs are dumped after the header,
>- *      which has the number of colors (=0 for monochrome) in place of the
>- *      V5 padding at the end. Up to 16-bit displays are supported. I
>- *      don't yet know how 24- to 32-bit displays will be handled under
>- *      the Version 11 protocol.
>- *
>- *  6/15/87 David Krikorian, MIT Project Athena
>- *    - VERSION 7 runs under the X Version 11 servers, while the previous
>- *      versions of xwd were are for X Version 10.  This version is based
>- *      on xwd version 6, and should eventually have the same color
>- *      abilities. (Xwd V7 has yet to be tested on a color machine, so
>- *      all color-related code is commented out until color support
>- *      becomes practical.)
>- */
>-
>-/*%
>- *%    This is the format for commenting out color-related code until
>- *%  color can be supported.
>-%*/
>-
>-#include <stdio.h>
>-#include <errno.h>
>-#include <X11/Xos.h>
>-
>-#ifdef X_NOT_STDC_ENV
>-extern int errno;
>-#endif
>-
>-#include <X11/Xlib.h>
>-#include <X11/Xutil.h>
>-
>-#include <X11/Xmu/WinUtil.h>
>-typedef unsigned long Pixel;
>-#include "X11/XWDFile.h"
>-
>-#define FEEP_VOLUME 0
>-
>-/* Include routines to do parsing */
>-#include "dsimple.h"
>-#include "list.h"
>-#include "wsutils.h"
>-#include "multiVis.h"
>-
>-#ifdef XKB
>-#include <X11/extensions/XKBbells.h>
>-#endif
>-
>-/* Setable Options */
>-
>-int format = ZPixmap;
>-Bool nobdrs = False;
>-Bool on_root = False;
>-Bool standard_out = True;
>-Bool debug = False;
>-Bool silent = False;
>-Bool use_installed = False;
>-long add_pixel_value = 0;
>-
>-extern int (*_XErrorFunction)();
>-extern int _XDefaultError();
>-
>-static long parse_long (s)
>-    char *s;
>-{
>-    char *fmt = "%lu";
>-    long retval = 0L;
>-    int thesign = 1;
>-
>-    if (s && s[0]) {
>-	if (s[0] == '-') s++, thesign = -1;
>-	if (s[0] == '0') s++, fmt = "%lo";
>-	if (s[0] == 'x' || s[0] == 'X') s++, fmt = "%lx";
>-	(void) sscanf (s, fmt, &retval);
>-    }
>-    return (thesign * retval);
>-}
>-
>-main(argc, argv)
>-    int argc;
>-    char **argv;
>-{
>-    register i;
>-    Window target_win;
>-    FILE *out_file = stdout;
>-    Bool frame_only = False;
>-
>-    INIT_NAME;
>-
>-    Setup_Display_And_Screen(&argc, argv);
>-
>-    /* Get window select on command line, if any */
>-    target_win = Select_Window_Args(&argc, argv);
>-
>-    for (i = 1; i < argc; i++) {
>-	if (!strcmp(argv[i], "-nobdrs")) {
>-	    nobdrs = True;
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-debug")) {
>-	    debug = True;
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-help"))
>-	  usage();
>-	if (!strcmp(argv[i], "-out")) {
>-	    if (++i >= argc) usage();
>-	    if (!(out_file = fopen(argv[i], "wb")))
>-	      Error("Can't open output file as specified.");
>-	    standard_out = False;
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-xy")) {
>-	    format = XYPixmap;
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-screen")) {
>-	    on_root = True;
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-icmap")) {
>-	    use_installed = True;
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-add")) {
>-	    if (++i >= argc) usage();
>-	    add_pixel_value = parse_long (argv[i]);
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-frame")) {
>-	    frame_only = True;
>-	    continue;
>-	}
>-	if (!strcmp(argv[i], "-silent")) {
>-	    silent = True;
>-	    continue;
>-	}
>-	usage();
>-    }
>-#ifdef WIN32
>-    if (standard_out)
>-	_setmode(fileno(out_file), _O_BINARY);
>-#endif
>-    
>-    /*
>-     * Let the user select the target window.
>-     */
>-    if (!target_win) {
>-	target_win = Select_Window(dpy);
>-	if (target_win != None && !frame_only) {
>-	    Window root;
>-	    int dummyi;
>-	    unsigned int dummy;
>-
>-	    if (XGetGeometry (dpy, target_win, &root, &dummyi, &dummyi,
>-			      &dummy, &dummy, &dummy, &dummy) &&
>-		target_win != root)
>-	      target_win = XmuClientWindow (dpy, target_win);
>-	}
>-  }
>-
>-
>-    /*
>-     * Dump it!
>-     */
>-    Window_Dump(target_win, out_file);
>-
>-    XCloseDisplay(dpy);
>-    if (fclose(out_file)) {
>-	perror("xwd");
>-	exit(1);
>-    }
>-    exit(0);
>-}
>-
>-static int
>-Get24bitDirectColors(colors)
>-XColor **colors ;
>-{
>-    int i , ncolors = 256 ;
>-    XColor *tcol ;
>-
>-    *colors = tcol = (XColor *)malloc(sizeof(XColor) * ncolors) ;
>-
>-    for(i=0 ; i < ncolors ; i++)
>-    {
>-	tcol[i].pixel = i << 16 | i << 8 | i ;
>-	tcol[i].red = tcol[i].green = tcol[i].blue = i << 8   | i ;
>-    }
>-
>-    return ncolors ;
>-}
>-
>-
>-/*
>- * Window_Dump: dump a window to a file which must already be open for
>- *              writting.
>- */
>-
>-char *calloc();
>-
>-Window_Dump(window, out)
>-     Window window;
>-     FILE *out;
>-{
>-    unsigned long swaptest = 1;
>-    XColor *colors;
>-    unsigned buffer_size;
>-    int win_name_size;
>-    int header_size;
>-    int ncolors, i;
>-    char *win_name;
>-    Bool got_win_name;
>-    XWindowAttributes win_info;
>-    XImage *image;
>-    int absx, absy, x, y;
>-    unsigned width, height;
>-    int dwidth, dheight;
>-    int bw;
>-    Window dummywin;
>-    XWDFileHeader header;
>-    XWDColor xwdcolor;
>-    
>-    int                 transparentOverlays , multiVis;
>-    int                 numVisuals;
>-    XVisualInfo         *pVisuals;
>-    int                 numOverlayVisuals;
>-    OverlayInfo         *pOverlayVisuals;
>-    int                 numImageVisuals;
>-    XVisualInfo         **pImageVisuals;
>-    list_ptr            vis_regions;    /* list of regions to read from */
>-    list_ptr            vis_image_regions ;
>-    Visual		vis_h,*vis ;
>-    int			allImage = 0 ;
>-
>-    /*
>-     * Inform the user not to alter the screen.
>-     */
>-    if (!silent) {
>-#ifdef XKB
>-	XkbStdBell(dpy,None,50,XkbBI_Wait);
>-#else
>-	XBell(dpy,FEEP_VOLUME);
>-#endif
>-	XFlush(dpy);
>-    }
>-
>-    /*
>-     * Get the parameters of the window being dumped.
>-     */
>-    if (debug) outl("xwd: Getting target window information.\n");
>-    if(!XGetWindowAttributes(dpy, window, &win_info)) 
>-      Fatal_Error("Can't get target window attributes.");
>-
>-    /* handle any frame window */
>-    if (!XTranslateCoordinates (dpy, window, RootWindow (dpy, screen), 0, 0,
>-				&absx, &absy, &dummywin)) {
>-	fprintf (stderr, 
>-		 "%s:  unable to translate window coordinates (%d,%d)\n",
>-		 program_name, absx, absy);
>-	exit (1);
>-    }
>-    win_info.x = absx;
>-    win_info.y = absy;
>-    width = win_info.width;
>-    height = win_info.height;
>-    bw = 0;
>-
>-    if (!nobdrs) {
>-	absx -= win_info.border_width;
>-	absy -= win_info.border_width;
>-	bw = win_info.border_width;
>-	width += (2 * bw);
>-	height += (2 * bw);
>-    }
>-    dwidth = DisplayWidth (dpy, screen);
>-    dheight = DisplayHeight (dpy, screen);
>-
>-
>-    /* clip to window */
>-    if (absx < 0) width += absx, absx = 0;
>-    if (absy < 0) height += absy, absy = 0;
>-    if (absx + width > dwidth) width = dwidth - absx;
>-    if (absy + height > dheight) height = dheight - absy;
>-
>-    XFetchName(dpy, window, &win_name);
>-    if (!win_name || !win_name[0]) {
>-	win_name = "xwdump";
>-	got_win_name = False;
>-    } else {
>-	got_win_name = True;
>-    }
>-
>-    /* sizeof(char) is included for the null string terminator. */
>-    win_name_size = strlen(win_name) + sizeof(char);
>-
>-    /*
>-     * Snarf the pixmap with XGetImage.
>-     */
>-
>-    x = absx - win_info.x;
>-    y = absy - win_info.y;
>-
>-    multiVis = GetMultiVisualRegions(dpy,RootWindow(dpy, screen), 
>-               absx, absy, 
>-	       width, height,&transparentOverlays,&numVisuals, &pVisuals,
>-               &numOverlayVisuals,&pOverlayVisuals,&numImageVisuals,
>-               &pImageVisuals,&vis_regions,&vis_image_regions,&allImage) ;
>-    if (on_root || multiVis)
>-    {
>-	if(!multiVis)
>-	    image = XGetImage (dpy, RootWindow(dpy, screen), absx, absy, 
>-                    width, height, AllPlanes, format);
>-	else
>-	    image = ReadAreaToImage(dpy, RootWindow(dpy, screen), absx, absy, 
>-                width, height,
>-    		numVisuals,pVisuals,numOverlayVisuals,pOverlayVisuals,
>-                numImageVisuals, pImageVisuals,vis_regions,
>-                vis_image_regions,format,allImage);
>-    }
>-    else
>-	image = XGetImage (dpy, window, x, y, width, height, AllPlanes, format);
>-    if (!image) {
>-	fprintf (stderr, "%s:  unable to get image at %dx%d+%d+%d\n",
>-		 program_name, width, height, x, y);
>-	exit (1);
>-    }
>-
>-    if (add_pixel_value != 0) XAddPixel (image, add_pixel_value);
>-
>-    /*
>-     * Determine the pixmap size.
>-     */
>-    buffer_size = Image_Size(image);
>-
>-    if (debug) outl("xwd: Getting Colors.\n");
>-
>-    if( !multiVis)
>-    {
>-       ncolors = Get_XColors(&win_info, &colors);
>-       vis = win_info.visual ;
>-    }
>-    else
>-    {
>-       ncolors = Get24bitDirectColors(&colors) ;
>-       initFakeVisual(&vis_h) ;
>-       vis = &vis_h ;
>-    }
>-    /*
>-     * Inform the user that the image has been retrieved.
>-     */
>-    if (!silent) {
>-#ifdef XKB
>-	XkbStdBell(dpy,window,FEEP_VOLUME,XkbBI_Proceed);
>-	XkbStdBell(dpy,window,FEEP_VOLUME,XkbBI_RepeatingLastBell);
>-#else
>-	XBell(dpy, FEEP_VOLUME);
>-	XBell(dpy, FEEP_VOLUME);
>-#endif
>-	XFlush(dpy);
>-    }
>-
>-    /*
>-     * Calculate header size.
>-     */
>-    if (debug) outl("xwd: Calculating header size.\n");
>-    header_size = SIZEOF(XWDheader) + win_name_size;
>-
>-    /*
>-     * Write out header information.
>-     */
>-    if (debug) outl("xwd: Constructing and dumping file header.\n");
>-    header.header_size = (CARD32) header_size;
>-    header.file_version = (CARD32) XWD_FILE_VERSION;
>-    header.pixmap_format = (CARD32) format;
>-    header.pixmap_depth = (CARD32) image->depth;
>-    header.pixmap_width = (CARD32) image->width;
>-    header.pixmap_height = (CARD32) image->height;
>-    header.xoffset = (CARD32) image->xoffset;
>-    header.byte_order = (CARD32) image->byte_order;
>-    header.bitmap_unit = (CARD32) image->bitmap_unit;
>-    header.bitmap_bit_order = (CARD32) image->bitmap_bit_order;
>-    header.bitmap_pad = (CARD32) image->bitmap_pad;
>-    header.bits_per_pixel = (CARD32) image->bits_per_pixel;
>-    header.bytes_per_line = (CARD32) image->bytes_per_line;
>-    /****
>-    header.visual_class = (CARD32) win_info.visual->class;
>-    header.red_mask = (CARD32) win_info.visual->red_mask;
>-    header.green_mask = (CARD32) win_info.visual->green_mask;
>-    header.blue_mask = (CARD32) win_info.visual->blue_mask;
>-    header.bits_per_rgb = (CARD32) win_info.visual->bits_per_rgb;
>-    header.colormap_entries = (CARD32) win_info.visual->map_entries;
>-    *****/
>-    header.visual_class = (CARD32) vis->class;
>-    header.red_mask = (CARD32) vis->red_mask;
>-    header.green_mask = (CARD32) vis->green_mask;
>-    header.blue_mask = (CARD32) vis->blue_mask;
>-    header.bits_per_rgb = (CARD32) vis->bits_per_rgb;
>-    header.colormap_entries = (CARD32) vis->map_entries;
>-
>-    header.ncolors = ncolors;
>-    header.window_width = (CARD32) win_info.width;
>-    header.window_height = (CARD32) win_info.height;
>-    header.window_x = absx;
>-    header.window_y = absy;
>-    header.window_bdrwidth = (CARD32) win_info.border_width;
>-
>-    if (*(char *) &swaptest) {
>-	_swaplong((char *) &header, sizeof(header));
>-	for (i = 0; i < ncolors; i++) {
>-	    _swaplong((char *) &colors[i].pixel, sizeof(long));
>-	    _swapshort((char *) &colors[i].red, 3 * sizeof(short));
>-	}
>-    }
>-
>-    if (fwrite((char *)&header, SIZEOF(XWDheader), 1, out) != 1 ||
>-	fwrite(win_name, win_name_size, 1, out) != 1) {
>-	perror("xwd");
>-	exit(1);
>-    }
>-
>-    /*
>-     * Write out the color maps, if any
>-     */
>-
>-    if (debug) outl("xwd: Dumping %d colors.\n", ncolors);
>-    for (i = 0; i < ncolors; i++) {
>-	xwdcolor.pixel = colors[i].pixel;
>-	xwdcolor.red = colors[i].red;
>-	xwdcolor.green = colors[i].green;
>-	xwdcolor.blue = colors[i].blue;
>-	xwdcolor.flags = colors[i].flags;
>-	if (fwrite((char *) &xwdcolor, SIZEOF(XWDColor), 1, out) != 1) {
>-	    perror("xwd");
>-	    exit(1);
>-	}
>-    }
>-
>-    /*
>-     * Write out the buffer.
>-     */
>-    if (debug) outl("xwd: Dumping pixmap.  bufsize=%d\n",buffer_size);
>-
>-    /*
>-     *    This copying of the bit stream (data) to a file is to be replaced
>-     *  by an Xlib call which hasn't been written yet.  It is not clear
>-     *  what other functions of xwd will be taken over by this (as yet)
>-     *  non-existant X function.
>-     */
>-    if (fwrite(image->data, (int) buffer_size, 1, out) != 1) {
>-	perror("xwd");
>-	exit(1);
>-    }
>-
>-    /*
>-     * free the color buffer.
>-     */
>-
>-    if(debug && ncolors > 0) outl("xwd: Freeing colors.\n");
>-    if(ncolors > 0) free(colors);
>-
>-    /*
>-     * Free window name string.
>-     */
>-    if (debug) outl("xwd: Freeing window name string.\n");
>-    if (got_win_name) XFree(win_name);
>-
>-    /*
>-     * Free image
>-     */
>-    XDestroyImage(image);
>-}
>-
>-/*
>- * Report the syntax for calling xwd.
>- */
>-usage()
>-{
>-    fprintf (stderr,
>-"usage: %s [-display host:dpy] [-debug] [-help] %s [-nobdrs] [-out <file>]",
>-	   program_name, SELECT_USAGE);
>-    fprintf (stderr, " [-xy] [-add value] [-frame]\n");
>-    exit(1);
>-}
>-
>-
>-/*
>- * Error - Fatal xwd error.
>- */
>-
>-Error(string)
>-	char *string;	/* Error description string. */
>-{
>-	outl("\nxwd: Error => %s\n", string);
>-	if (errno != 0) {
>-		perror("xwd");
>-		outl("\n");
>-	}
>-
>-	exit(1);
>-}
>-
>-
>-/*
>- * Determine the pixmap size.
>- */
>-
>-int Image_Size(image)
>-     XImage *image;
>-{
>-    if (image->format != ZPixmap)
>-      return(image->bytes_per_line * image->height * image->depth);
>-
>-    return(image->bytes_per_line * image->height);
>-}
>-
>-#define lowbit(x) ((x) & (~(x) + 1))
>-
>-static int
>-ReadColors(vis,cmap,colors)
>-Visual *vis ;
>-Colormap cmap ;
>-XColor **colors ;
>-{
>-    int i,ncolors ;
>-
>-    ncolors = vis->map_entries;
>-
>-    if (!(*colors = (XColor *) malloc (sizeof(XColor) * ncolors)))
>-      Fatal_Error("Out of memory!");
>-
>-    if (vis->class == DirectColor ||
>-	vis->class == TrueColor) {
>-	Pixel red, green, blue, red1, green1, blue1;
>-
>-	red = green = blue = 0;
>-	red1 = lowbit(vis->red_mask);
>-	green1 = lowbit(vis->green_mask);
>-	blue1 = lowbit(vis->blue_mask);
>-	for (i=0; i<ncolors; i++) {
>-	  (*colors)[i].pixel = red|green|blue;
>-	  (*colors)[i].pad = 0;
>-	  red += red1;
>-	  if (red > vis->red_mask)
>-	    red = 0;
>-	  green += green1;
>-	  if (green > vis->green_mask)
>-	    green = 0;
>-	  blue += blue1;
>-	  if (blue > vis->blue_mask)
>-	    blue = 0;
>-	}
>-    } else {
>-	for (i=0; i<ncolors; i++) {
>-	  (*colors)[i].pixel = i;
>-	  (*colors)[i].pad = 0;
>-	}
>-    }
>-
>-    XQueryColors(dpy, cmap, *colors, ncolors);
>-    
>-    return(ncolors);
>-}
>-
>-/*
>- * Get the XColors of all pixels in image - returns # of colors
>- */
>-int Get_XColors(win_info, colors)
>-     XWindowAttributes *win_info;
>-     XColor **colors;
>-{
>-    int i, ncolors;
>-    Colormap cmap = win_info->colormap;
>-
>-    if (use_installed)
>-	/* assume the visual will be OK ... */
>-	cmap = XListInstalledColormaps(dpy, win_info->root, &i)[0];
>-    if (!cmap)
>-	return(0);
>-    ncolors = ReadColors(win_info->visual,cmap,colors) ;
>-    return ncolors ;
>-}
>-
>-_swapshort (bp, n)
>-    register char *bp;
>-    register unsigned n;
>-{
>-    register char c;
>-    register char *ep = bp + n;
>-
>-    while (bp < ep) {
>-	c = *bp;
>-	*bp = *(bp + 1);
>-	bp++;
>-	*bp++ = c;
>-    }
>-}
>-
>-_swaplong (bp, n)
>-    register char *bp;
>-    register unsigned n;
>-{
>-    register char c;
>-    register char *ep = bp + n;
>-    register char *sp;
>-
>-    while (bp < ep) {
>-	sp = bp + 3;
>-	c = *sp;
>-	*sp = *bp;
>-	*bp++ = c;
>-	sp = bp + 1;
>-	c = *sp;
>-	*sp = *bp;
>-	*bp++ = c;
>-	bp += 2;
>-    }
>-}
>Index: xc/programs/xwd/xwd.man
>===================================================================
>RCS file: xc/programs/xwd/xwd.man
>diff -N xc/programs/xwd/xwd.man
>--- xc/programs/xwd/xwd.man	28 May 2002 01:50:58 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,130 +0,0 @@
>-.\" $Xorg: xwd.man,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $
>-.\" Copyright 1988, 1994, 1998  The Open Group
>-.\" 
>-.\" Permission to use, copy, modify, distribute, and sell this software and its
>-.\" documentation for any purpose is hereby granted without fee, provided that
>-.\" the above copyright notice appear in all copies and that both that
>-.\" copyright notice and this permission notice appear in supporting
>-.\" documentation.
>-.\" 
>-.\" 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 OPEN GROUP 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 of The Open Group shall
>-.\" not be used in advertising or otherwise to promote the sale, use or
>-.\" other dealings in this Software without prior written authorization
>-.\" from The Open Group.
>-.TH XWD 1 "Release 6.4" "X Version 11"
>-.SH NAME
>-xwd - dump an image of an X window
>-.SH SYNOPSIS
>-.B "xwd"
>-[-debug] [-help] [-nobdrs] [-out \fIfile\fP] [-xy] [-frame] [-add \fIvalue\fP]
>-[-root | -id \fIid\fP | -name \fIname\fP ] [-icmap] [-screen]
>-[-display \fIdisplay\fP]
>-.SH DESCRIPTION
>-.PP
>-.I Xwd
>-is an X Window System window dumping utility.
>-.I Xwd
>-allows X users to store window images in a specially formatted dump
>-file.  This file can then be read by various other X utilities for
>-redisplay, printing, editing, formatting, archiving, image processing, etc.
>-The target window is selected by clicking the pointer in the desired window.
>-The keyboard bell is rung once at the beginning of the dump and twice when
>-the dump is completed.
>-.SH OPTIONS
>-.PP
>-.TP 8
>-.B "-display \fIdisplay\fP"
>-This argument allows you to specify the server to connect to; see \fIX(1)\fP.
>-.PP
>-.TP 8
>-.B "-help"
>-Print out the `Usage:' command syntax summary.
>-.PP
>-.TP 8
>-.B "-nobdrs"
>-This argument specifies that the window dump should not include the
>-pixels that compose the X window border.  This is useful in situations
>-where you may wish to include the window contents in a document 
>-as an illustration.
>-.PP
>-.TP 8
>-.B "-out \fIfile\fP"
>-This argument allows the user to explicitly specify the output
>-file on the command line.  The default is to output to standard out.
>-.PP
>-.TP 8
>-.B "-xy"
>-This option applies to color displays only. It selects `XY' format dumping
>-instead of the default `Z' format.
>-.PP
>-.TP 8
>-.B "-add \fIvalue\fP"
>-This option specifies an signed value to be added to every pixel.
>-.PP
>-.TP 8
>-.B "-frame"
>-This option indicates that the window manager frame should be included when
>-manually selecting a window.
>-.PP
>-.TP 8
>-.B "-root"
>-This option indicates that the root window should be selected for the
>-window dump, without requiring the user to select a window with the pointer.
>-.PP
>-.TP 8
>-.B "-id \fIid\fP"
>-This option indicates that the window with the specified resource id
>-should be selected for the window dump, without requiring the user to
>-select a window with the pointer.
>-.PP
>-.TP 8
>-.B "-name \fIname\fP"
>-This option indicates that the window with the specified WM_NAME property
>-should be selected for the window dump, without requiring the user to
>-select a window with the pointer.
>-.PP
>-.TP 8
>-.B "-icmap"
>-Normally the colormap of the chosen window is used to obtain RGB values.
>-This option forces the first installed colormap of the screen to be used
>-instead.
>-.PP
>-.TP 8
>-.B "-screen"
>-This option indicates that the GetImage request used to obtain the image
>-should be done on the root window, rather than directly on the specified
>-window.  In this way, you can obtain pieces of other windows that overlap
>-the specified window, and more importantly, you can capture menus or other
>-popups that are independent windows but appear over the specified window.
>-.PP
>-.TP 8
>-.B "-silent"
>-Operate silently, i.e. don't ring any bells before and after dumping
>-the window.
>-.SH ENVIRONMENT
>-.PP
>-.TP 8
>-.B DISPLAY
>-To get default host and display number.
>-.SH FILES
>-.PP
>-.TP 8
>-.B XWDFile.h
>-X Window Dump File format definition file.
>-.SH SEE ALSO
>-xwud(1), xpr(1), X(1)
>-.SH AUTHORS
>-Tony Della Fera, Digital Equipment Corp., MIT Project Athena
>-.br
>-William F. Wyatt, Smithsonian Astrophysical Observatory
>Index: xc/programs/xwud/Imakefile
>===================================================================
>RCS file: xc/programs/xwud/Imakefile
>diff -N xc/programs/xwud/Imakefile
>--- xc/programs/xwud/Imakefile	28 May 2002 01:50:59 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,5 +0,0 @@
>-XCOMM $Xorg: Imakefile,v 1.3 2000/08/17 19:55:17 cpqbld Exp $
>-        DEPLIBS = $(DEPXONLYLIB)
>-LOCAL_LIBRARIES = $(XONLYLIB)
>-
>-SimpleProgramTarget(xwud)
>Index: xc/programs/xwud/xwud.c
>===================================================================
>RCS file: xc/programs/xwud/xwud.c
>diff -N xc/programs/xwud/xwud.c
>--- xc/programs/xwud/xwud.c	28 May 2002 01:50:59 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,1144 +0,0 @@
>-/* $Xorg: xwud.c,v 1.5 2001/02/09 02:06:04 xorgcvs Exp $ */
>-/*
>-
>-Copyright 1985, 1986, 1988, 1998  The Open Group
>-
>-Permission to use, copy, modify, distribute, and sell this software and its
>-documentation for any purpose is hereby granted without fee, provided that
>-the above copyright notice appear in all copies and that both that
>-copyright notice and this permission notice appear in supporting
>-documentation.
>-
>-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 OPEN GROUP 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 of The Open Group shall
>-not be used in advertising or otherwise to promote the sale, use or
>-other dealings in this Software without prior written authorization
>-from The Open Group.
>-
>-*/
>-
>-/* xwud - marginally useful raster image undumper */
>-
>-
>-#include <X11/Xos.h>
>-#include <X11/Xlib.h>
>-#include <X11/Xutil.h>
>-#include <X11/Xatom.h>
>-#include <stdio.h>
>-#include <X11/XWDFile.h>
>-#define  XK_LATIN1
>-#include <X11/keysymdef.h>
>-#include <errno.h>
>-
>-#ifdef X_NOT_STDC_ENV
>-extern int errno;
>-#endif
>-
>-extern char *malloc();
>-unsigned Image_Size();
>-Atom wm_protocols;
>-Atom wm_delete_window;
>-int split;
>-
>-char *progname;
>-
>-usage()
>-{
>-    fprintf(stderr, "usage: %s [-in <file>] [-noclick] [-geometry <geom>] [-display <display>]\n", progname);
>-    fprintf(stderr, "            [-new] [-std <maptype>] [-raw] [-vis <vis-type-or-id>]\n");
>-    fprintf(stderr, "            [-help] [-rv] [-plane <number>] [-fg <color>] [-bg <color>]\n");
>-    fprintf(stderr, "            [-scale]\n");
>-    exit(1);
>-}
>-
>-Bool
>-Read(ptr, size, nitems, stream)
>-    char *ptr;
>-    int size;
>-    int nitems;
>-    FILE *stream;
>-{
>-    size *= nitems;
>-    while (size) {
>-	nitems = fread(ptr, 1, size, stream);
>-	if (nitems <= 0)
>-	    return False;
>-	size -= nitems;
>-	ptr += nitems;
>-    }
>-    return True;
>-}
>-
>-main(argc, argv)
>-    int argc;
>-    char **argv;
>-{
>-    Display *dpy;
>-    int screen;
>-    register int i;
>-    XImage in_image_struct;
>-    XImage *in_image, *out_image;
>-    XSetWindowAttributes attributes;
>-    XVisualInfo vinfo, *vinfos;
>-    long mask;
>-    register char *buffer;
>-    unsigned long swaptest = 1;
>-    int count, stdcnt;
>-    unsigned buffer_size;
>-    int win_name_size;
>-    int ncolors;
>-    char *file_name = NULL;
>-    char *win_name;
>-    Bool inverse = False, rawbits = False, newmap = False;
>-    Bool onclick = True;
>-    Bool scale = False;
>-    int plane = -1;
>-    char *std = NULL;
>-    char *vis = NULL;
>-    char *display_name = NULL;
>-    char *fgname = NULL;
>-    char *bgname = NULL;
>-    char *geom = NULL;
>-    int gbits = 0;
>-    XSizeHints hints;
>-    XTextProperty textprop;
>-    XClassHint class_hint;
>-    XColor *colors, color, igncolor;
>-    Window image_win;
>-    Colormap colormap;
>-    XEvent event;
>-    register XExposeEvent *expose = (XExposeEvent *)&event;
>-    GC gc;
>-    XGCValues gc_val;
>-    XWDFileHeader header;
>-    XWDColor xwdcolor;
>-    FILE *in_file = stdin;
>-    char *map_name;
>-    Atom map_prop;
>-    XStandardColormap *stdmaps, *stdmap;
>-    char c;
>-    int win_width, win_height;
>-
>-    progname = argv[0];
>-
>-    for (i = 1; i < argc; i++) {
>-	if (strcmp(argv[i], "-bg") == 0) {
>-	    if (++i >= argc) usage();
>-	    bgname = argv[i];
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-display") == 0) {
>-	    if (++i >= argc) usage();
>-	    display_name = argv[i];
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-fg") == 0) {
>-	    if (++i >= argc) usage();
>-	    fgname = argv[i];
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-geometry") == 0) {
>-	    if (++i >= argc) usage();
>-	    geom = argv[i];
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-help") == 0) {
>-	    usage();
>-	}
>-	if (strcmp(argv[i], "-in") == 0) {
>-	    if (++i >= argc) usage();
>-	    file_name = argv[i];
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-inverse") == 0) { /* for compatibility */
>-	    inverse = True;
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-new") == 0) {
>-	    newmap = True;
>-	    if (std) usage();
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-noclick") == 0) {
>-	    onclick = False;
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-plane") == 0) {
>-	    if (++i >= argc) usage();
>-	    plane = atoi(argv[i]);
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-raw") == 0) {
>-	    rawbits = True;
>-	    if (std) usage();
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-rv") == 0) {
>-	    inverse = True;
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-scale") == 0) {
>-	    scale = True;
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-split") == 0) {
>-	    split = True;
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-std") == 0) {
>-	    if (++i >= argc) usage();
>-	    std = argv[i];
>-	    if (newmap || rawbits) usage();
>-	    continue;
>-	}
>-	if (strcmp(argv[i], "-vis") == 0) {
>-	    if (++i >= argc) usage();
>-	    vis = argv[i];
>-	    continue;
>-	}
>-	usage();
>-    }
>-    
>-    if (file_name) {
>-	in_file = fopen(file_name, "rb");
>-	if (in_file == NULL)
>-	    Error("Can't open input file as specified.");
>-    }
>-#ifdef WIN32
>-    else
>-	_setmode(fileno(in_file), _O_BINARY);
>-#endif
>-    
>-    dpy = XOpenDisplay(display_name);
>-    if (dpy == NULL) {
>-	fprintf(stderr, "%s:  unable to open display \"%s\"\n",
>-		progname, XDisplayName(display_name));
>-	exit(1);
>-    }
>-    screen = DefaultScreen(dpy);
>-
>-    /*
>-     * Read in header information.
>-     */
>-    if(!Read((char *)&header, SIZEOF(XWDheader), 1, in_file))
>-      Error("Unable to read dump file header.");
>-
>-    if (*(char *) &swaptest)
>-	_swaplong((char *) &header, SIZEOF(XWDheader));
>-
>-    /* check to see if the dump file is in the proper format */
>-    if (header.file_version != XWD_FILE_VERSION) {
>-	fprintf(stderr,"xwud: XWD file format version mismatch.");
>-	Error("exiting.");
>-    }
>-    if (header.header_size < SIZEOF(XWDheader)) {
>-	fprintf(stderr,"xwud: XWD header size is too small.");
>-	Error("exiting.");
>-    }
>-
>-    /* alloc window name */
>-    win_name_size = (header.header_size - SIZEOF(XWDheader));
>-    if((win_name = malloc((unsigned) win_name_size + 6)) == NULL)
>-      Error("Can't malloc window name storage.");
>-    strcpy(win_name, "xwud: ");
>-
>-     /* read in window name */
>-    if(!Read(win_name + 6, sizeof(char), win_name_size, in_file))
>-      Error("Unable to read window name from dump file.");
>-
>-    /* initialize the input image */
>-
>-    in_image = &in_image_struct;
>-    in_image->depth = header.pixmap_depth;
>-    in_image->format = header.pixmap_format;
>-    in_image->xoffset = header.xoffset;
>-    in_image->data = NULL;
>-    in_image->width = header.pixmap_width;
>-    in_image->height = header.pixmap_height;
>-    in_image->bitmap_pad = header.bitmap_pad;
>-    in_image->bytes_per_line = header.bytes_per_line;
>-    in_image->byte_order = header.byte_order;
>-    in_image->bitmap_unit = header.bitmap_unit;
>-    in_image->bitmap_bit_order = header.bitmap_bit_order;
>-    in_image->bits_per_pixel = header.bits_per_pixel;
>-    in_image->red_mask = header.red_mask;
>-    in_image->green_mask = header.green_mask;
>-    in_image->blue_mask = header.blue_mask;
>-    if (!XInitImage(in_image))
>-	Error("Invalid input image header data.");
>-
>-    /* read in the color map buffer */
>-    if((ncolors = header.ncolors)) {
>-	colors = (XColor *)malloc((unsigned) ncolors * sizeof(XColor));
>-	if (!colors)
>-	    Error("Can't malloc color table");
>-	for (i = 0; i < ncolors; i++) {
>-	    if(!Read((char *) &xwdcolor, SIZEOF(XWDColor), 1, in_file))
>-		Error("Unable to read color map from dump file.");
>-	    colors[i].pixel = xwdcolor.pixel;
>-	    colors[i].red = xwdcolor.red;
>-	    colors[i].green = xwdcolor.green;
>-	    colors[i].blue = xwdcolor.blue;
>-	    colors[i].flags = xwdcolor.flags;
>-	}
>-	if (*(char *) &swaptest) {
>-	    for (i = 0; i < ncolors; i++) {
>-		_swaplong((char *) &colors[i].pixel, sizeof(long));
>-		_swapshort((char *) &colors[i].red, 3 * sizeof(short));
>-	    }
>-	}
>-    }
>-    else
>-	/* no color map exists, turn on the raw option */
>-	rawbits = True;
>-
>-    /* alloc the pixel buffer */
>-    buffer_size = Image_Size(in_image);
>-    if((buffer = malloc(buffer_size)) == NULL)
>-      Error("Can't malloc data buffer.");
>-
>-    /* read in the image data */
>-    if (!Read(buffer, sizeof(char), (int)buffer_size, in_file))
>-        Error("Unable to read pixmap from dump file.");
>-
>-     /* close the input file */
>-    (void) fclose(in_file);
>-
>-    if (plane >= in_image->depth)
>-	Error("plane number exceeds image depth");
>-    if ((in_image->format == XYPixmap) && (plane >= 0)) {
>-	buffer += in_image->bytes_per_line * in_image->height *
>-		  (in_image->depth - (plane + 1));
>-	in_image->depth = 1;
>-	ncolors = 0;
>-    }
>-    if (in_image->bits_per_pixel == 1 && in_image->depth == 1) {
>-	in_image->format = XYBitmap;
>-	newmap = False;
>-	rawbits = True;
>-    }
>-    in_image->data = buffer;
>-
>-    if (std) {
>-	map_name = malloc(strlen(std) + 9);
>-	strcpy(map_name, "RGB_");
>-	strcat(map_name, std);
>-	strcat(map_name, "_MAP");
>-	Latin1Upper(map_name);
>-	map_prop = XInternAtom(dpy, map_name, True);
>-	if (!map_prop || !XGetRGBColormaps(dpy, RootWindow(dpy, screen),
>-					   &stdmaps, &stdcnt, map_prop))
>-	    Error("specified standard colormap does not exist");
>-    }
>-    vinfo.screen = screen;
>-    mask = VisualScreenMask;
>-    if (vis)
>-    {
>-	char *vt;
>-	vt = malloc(strlen(vis) + 1);
>-	strcpy(vt, vis);
>-	Latin1Upper(vt);
>-	if (strcmp(vt, "STATICGRAY") == 0) {
>-	    vinfo.class = StaticGray;
>-	    mask |= VisualClassMask;
>-	} else if (strcmp(vt, "GRAYSCALE") == 0) {
>-	    vinfo.class = GrayScale;
>-	    mask |= VisualClassMask;
>-	} else if (strcmp(vt, "STATICCOLOR") == 0) {
>-	    vinfo.class = StaticColor;
>-	    mask |= VisualClassMask;
>-	} else if (strcmp(vt, "PSEUDOCOLOR") == 0) {
>-	    vinfo.class = PseudoColor;
>-	    mask |= VisualClassMask;
>-	} else if (strcmp(vt, "DIRECTCOLOR") == 0) {
>-	    vinfo.class = DirectColor;
>-	    mask |= VisualClassMask;
>-	} else if (strcmp(vt, "TRUECOLOR") == 0) {
>-	    vinfo.class = TrueColor;
>-	    mask |= VisualClassMask;
>-	} else if (strcmp(vt, "MATCH") == 0) {
>-	    vinfo.class = header.visual_class;
>-	    mask |= VisualClassMask;
>-	} else if (strcmp(vt, "DEFAULT") == 0) {
>-	    vinfo.visualid= XVisualIDFromVisual(DefaultVisual(dpy, screen));
>-	    mask |= VisualIDMask;
>-	} else {
>-	    vinfo.visualid = 0;
>-	    mask |= VisualIDMask;
>-	    sscanf(vis, "0x%lx", &vinfo.visualid);
>-	    if (!vinfo.visualid)
>-	      sscanf(vis, "%ld", &vinfo.visualid);
>-	    if (!vinfo.visualid)
>-	      Error("invalid visual specifier");
>-	}
>-    }
>-    if (rawbits && (in_image->depth > 1) && (plane < 0)) {
>-	vinfo.depth = in_image->depth;
>-	mask |= VisualDepthMask;
>-    }
>-    vinfos = XGetVisualInfo(dpy, mask, &vinfo, &count);
>-    if (count == 0)
>-	Error("no matching visual found");
>-
>-    /* find a workable visual */
>-    if (std) {
>-	stdmap = &stdmaps[0];
>-	if (mask & VisualIDMask) {
>-	    for (i = 0; i < stdcnt; i++) {
>-		if (stdmaps[i].visualid == vinfo.visualid) {
>-		    stdmap = &stdmaps[i];
>-		    break;
>-		}
>-	    }
>-	    if (stdmap->visualid != vinfo.visualid)
>-		Error("no standard colormap matching specified visual");
>-	}
>-	for (i = 0; i < count; i++) {
>-	    if (stdmap->visualid == vinfos[i].visualid) {
>-		vinfo = vinfos[i];
>-		break;
>-	    }
>-	}
>-    } else if ((in_image->depth == 1) ||
>-	       ((in_image->format == ZPixmap) && (plane >= 0)) ||
>-	       rawbits) {
>-	vinfo = vinfos[0];
>-	if (!(mask & VisualIDMask)) {
>-	    for (i = 0; i < count; i++) {
>-		if ((vinfos[i].visualid ==
>-		     XVisualIDFromVisual(DefaultVisual(dpy, screen))) &&
>-		    (vinfos[i].depth == DefaultDepth(dpy, screen))) {
>-		    vinfo = vinfos[i];
>-		    break;
>-		}
>-	    }
>-	}
>-    } else {
>-	/* get best visual */
>-	vinfo = vinfos[0];
>-	for (i = 0; i < count; i++) {
>-	    int z1, z2;
>-	    z2 = EffectiveSize(&vinfos[i]);
>-	    if ((z2 >= ncolors) &&
>-		(vinfos[i].depth == in_image->depth) &&
>-		(vinfos[i].class == header.visual_class))
>-	    {
>-		vinfo = vinfos[i];
>-		break;
>-	    }
>-	    z1 = EffectiveSize(&vinfo);
>-	    if ((z2 > z1) ||
>-		((z2 == z1) &&
>-		 (VisualRank(vinfos[i].class) >= VisualRank(vinfo.class))))
>-		vinfo = vinfos[i];
>-	}
>-	if ((newmap || (vinfo.visual != DefaultVisual(dpy, screen))) &&
>-	    (vinfo.class != StaticGray) &&
>-	    (vinfo.class != StaticColor) &&
>-	    (vinfo.class == header.visual_class) &&
>-	    (vinfo.depth == in_image->depth) &&
>-	    ((vinfo.class == PseudoColor) ||
>-	     (vinfo.class == GrayScale) ||
>-	     ((vinfo.red_mask == header.red_mask) &&
>-	      (vinfo.green_mask == header.green_mask) &&
>-	      (vinfo.blue_mask == header.blue_mask)))) {
>-	    rawbits = True;
>-	    newmap = True;
>-	}
>-    }
>-
>-    /* get the appropriate colormap */
>-    if (newmap && (vinfo.class & 1) &&
>-	(vinfo.depth == in_image->depth) &&
>-	(vinfo.class == header.visual_class) &&
>-	(vinfo.colormap_size >= ncolors) &&
>-	(vinfo.red_mask == header.red_mask) &&
>-	(vinfo.green_mask == header.green_mask) &&
>-	(vinfo.blue_mask == header.blue_mask)) {
>-	colormap = XCreateColormap(dpy, RootWindow(dpy, screen), vinfo.visual,
>-				   AllocAll);
>-	if (ncolors) {
>-	    for (i = 0; i < ncolors; i++)
>-		colors[i].flags = DoRed|DoGreen|DoBlue;
>-	    XStoreColors(dpy, colormap, colors, ncolors);
>-	}
>-    } else if (std) {
>-	colormap = stdmap->colormap;
>-    } else {
>-	if (!newmap && (vinfo.visual == DefaultVisual(dpy, screen)))
>-	    colormap = DefaultColormap(dpy, screen);
>-	else
>-	    colormap = XCreateColormap(dpy, RootWindow(dpy, screen),
>-				       vinfo.visual, AllocNone);
>-	newmap = False;
>-    }
>-
>-    /* create the output image */
>-    if ((in_image->format == ZPixmap) && (plane >= 0)) {
>-	out_image = XCreateImage(dpy, vinfo.visual, 1,
>-				 XYBitmap, 0, NULL,
>-				 in_image->width, in_image->height,
>-				 XBitmapPad(dpy), 0);
>-	out_image->data = malloc(Image_Size(out_image));
>-	Extract_Plane(in_image, out_image, plane);
>-	ncolors = 0;
>-    } else if (rawbits || newmap) {
>-	out_image = in_image;
>-    } else {
>-	out_image = XCreateImage(dpy, vinfo.visual, vinfo.depth,
>-				 (vinfo.depth == 1) ? XYBitmap :
>-						      in_image->format,
>-				 in_image->xoffset, NULL,
>-				 in_image->width, in_image->height,
>-				 XBitmapPad(dpy), 0);
>-	out_image->data = malloc(Image_Size(out_image));
>-	if (std) {
>-	    if (!stdmap->green_max && !stdmap->blue_max && IsGray(dpy, stdmap))
>-		Do_StdGray(dpy, stdmap, ncolors, colors, in_image, out_image);
>-	    else
>-		Do_StdCol(dpy, stdmap, ncolors, colors, in_image, out_image);
>-	} else if ((header.visual_class == TrueColor) ||
>-		   (header.visual_class == DirectColor))
>-	    Do_Direct(dpy, &header, &colormap, ncolors, colors,
>-		      in_image, out_image);
>-	else
>-	    Do_Pseudo(dpy, &colormap, ncolors, colors, in_image, out_image);
>-    }
>-
>-    if (out_image->depth == 1) {
>-	if (fgname &&
>-	    XAllocNamedColor(dpy, colormap, fgname, &color, &igncolor))
>-	    gc_val.foreground = color.pixel;
>-	else if ((ncolors == 2) && XAllocColor(dpy, colormap, &colors[1]))
>-	    gc_val.foreground = colors[1].pixel;
>-	else
>-	    gc_val.foreground = BlackPixel (dpy, screen);
>-	if (bgname &&
>-	    XAllocNamedColor(dpy, colormap, bgname, &color, &igncolor))
>-	    gc_val.background = color.pixel;
>-	else if ((ncolors == 2) && XAllocColor(dpy, colormap, &colors[0]))
>-	    gc_val.background = colors[0].pixel;
>-	else
>-	    gc_val.background = WhitePixel (dpy, screen);
>-	if (inverse) {
>-	    unsigned long tmp;
>-	    tmp = gc_val.foreground;
>-	    gc_val.foreground = gc_val.background;
>-	    gc_val.background = tmp;
>-	}
>-    } else {
>-	gc_val.background = XGetPixel(out_image, 0, 0);
>-	gc_val.foreground = 0;
>-    }
>-
>-    attributes.background_pixel = gc_val.background;
>-    attributes.border_pixel = gc_val.background;
>-    if (scale)
>-	attributes.bit_gravity = ForgetGravity;
>-    else
>-	attributes.bit_gravity = NorthWestGravity;
>-    attributes.event_mask = ButtonPressMask|ButtonReleaseMask|KeyPressMask|
>-			    ExposureMask;
>-    if (scale)
>-	attributes.event_mask |= StructureNotifyMask;
>-    attributes.colormap = colormap;
>-
>-    hints.x = header.window_x;
>-    hints.y = header.window_y;
>-    hints.width = out_image->width;
>-    hints.height = out_image->height;
>-    if (geom)
>-	gbits = XParseGeometry(geom, &hints.x, &hints.y,
>-			       (unsigned int *)&hints.width,
>-			       (unsigned int *)&hints.height);
>-    hints.flags = ((gbits & (XValue|YValue)) ? USPosition : 0) |
>-		  ((gbits & (HeightValue|WidthValue)) ? USSize : PSize);
>-    if (!scale) {
>-	hints.flags |= PMaxSize;
>-	hints.max_width = (hints.width > out_image->width) ?
>-	    hints.width : out_image->width;
>-	hints.max_height = (hints.height > out_image->height) ?
>-	    hints.height : out_image->height;
>-    }
>-    if ((gbits & XValue) && (gbits & XNegative))
>-	hints.x += DisplayWidth(dpy, screen) - hints.width; 
>-    if ((gbits & YValue) && (gbits & YNegative))
>-	hints.y += DisplayHeight(dpy, screen) - hints.height;
>-
>-    /* create the image window */
>-    image_win = XCreateWindow(dpy, RootWindow(dpy, screen),
>-			      hints.x, hints.y, hints.width, hints.height,
>-			      0, vinfo.depth, InputOutput, vinfo.visual,
>-			      CWBorderPixel|CWBackPixel|CWColormap|CWEventMask|CWBitGravity,
>-			      &attributes);
>-    win_width = hints.width;
>-    win_height = hints.height;
>-
>-    /* Setup for ICCCM delete window. */
>-    wm_protocols = XInternAtom(dpy, "WM_PROTOCOLS", False);
>-    wm_delete_window = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
>-    (void) XSetWMProtocols (dpy, image_win, &wm_delete_window, 1);
>-     
>-    textprop.value = (unsigned char *) win_name;
>-    textprop.encoding = XA_STRING;
>-    textprop.format = 8;
>-    textprop.nitems = strlen(win_name);
>-    class_hint.res_name = (char *)NULL;
>-    class_hint.res_class = "Xwud";
>-    /* set standard properties */
>-    XSetWMProperties(dpy, image_win, &textprop, (XTextProperty *)NULL,
>-		     argv, argc, &hints, (XWMHints *)NULL, &class_hint);
>-
>-    /* map the image window */
>-    XMapWindow(dpy, image_win);
>-
>-    gc = XCreateGC (dpy, image_win, GCForeground|GCBackground, &gc_val);
>-
>-    while (1) {
>-	/* wait on mouse input event to terminate */
>-	XNextEvent(dpy, &event);
>-	switch(event.type) {
>-	case ClientMessage:
>-	  if (event.xclient.message_type == wm_protocols && 
>-	      event.xclient.data.l[0] == wm_delete_window)  {
>-	    XCloseDisplay(dpy);
>-	    exit(0);		/* ICCCM delete window */
>-	  }
>-	    break;
>-	case ButtonPress:
>-	    break;
>-	case ButtonRelease:
>-	    if (onclick) {
>-		XCloseDisplay(dpy);
>-		exit(0);
>-	    }
>-	    break;
>-	case KeyPress:
>-	    i = XLookupString(&event.xkey, &c, 1, NULL, NULL);
>-	    if ((i == 1) && ((c == 'q') || (c == 'Q') || (c == '\03'))) {
>-		XCloseDisplay(dpy);
>-		exit(0);
>-	    }
>-	    break;
>-	case ConfigureNotify:
>-	    win_width = event.xconfigure.width;
>-	    win_height = event.xconfigure.height;
>-	    break;
>-	case Expose:
>-	    if (scale)
>-		putScaledImage(dpy, image_win, gc, out_image,
>-			       expose->x, expose->y,
>-			       expose->width, expose->height,
>-			       win_width, win_height);
>-	    else if ((expose->x < out_image->width) &&
>-		     (expose->y < out_image->height)) {
>-		if ((out_image->width - expose->x) < expose->width)
>-		    expose->width = out_image->width - expose->x;
>-		if ((out_image->height - expose->y) < expose->height)
>-		    expose->height = out_image->height - expose->y;
>-		putImage(dpy, image_win, gc, out_image,
>-			  expose->x, expose->y,
>-			  expose->width, expose->height);
>-	    }
>-	    break;
>-	}
>-    }
>-}
>-
>-putImage (dpy, image_win, gc, out_image, x, y, w, h)
>-    Display	*dpy;
>-    Window	image_win;
>-    GC		gc;
>-    XImage	*out_image;
>-    int		x, y, w, h;
>-{
>-#define SPLIT_SIZE  100
>-    int	t_x, t_y, t_w, t_h;
>-    if (split) {
>-    	for (t_y = y; t_y < y + h; t_y += t_h) {
>-    	    t_h = SPLIT_SIZE;
>-    	    if (t_y + t_h > y + h)
>-	    	t_h = y + h - t_y;
>-    	    for (t_x = x; t_x < x + w; t_x += t_w) {
>-	    	t_w = SPLIT_SIZE;
>-	    	if (t_x + t_w > x + w)
>-	    	    t_w = x + w - t_x;
>-	    	XPutImage(dpy, image_win, gc, out_image,
>-		      	  t_x, t_y, t_x, t_y, t_w, t_h);
>-    	    }
>-    	}
>-    } else {
>-	XPutImage (dpy, image_win, gc, out_image, x, y, x, y, w, h);
>-    }
>-}
>-
>-typedef short Position;
>-typedef unsigned short Dimension;
>-typedef unsigned long Pixel;
>-
>-#define roundint(x)                   (int)((x) + 0.5)
>-
>-typedef struct {
>-  Position *x, *y;
>-  Dimension *width, *height;
>-} Table;
>-
>-putScaledImage(display, d, gc, src_image, exp_x, exp_y,
>-	       exp_width, exp_height, dest_width, dest_height)
>-    Display*		 display;
>-    Drawable		 d;
>-    GC			 gc;
>-    XImage*		 src_image;
>-    int			 exp_x;
>-    int			 exp_y;
>-    unsigned int	 exp_width;
>-    unsigned int	 exp_height;
>-    unsigned int	 dest_width;
>-    unsigned int	 dest_height;
>-{
>-    XImage *dest_image;
>-    Position x, y, min_y, max_y, exp_max_y, src_x, src_max_x, src_y;
>-    Dimension w, h, strip_height;
>-    Table table;    
>-    Pixel pixel;
>-    double ratio_x, ratio_y;
>-    Bool fast8;
>-
>-    if (dest_width == src_image->width && dest_height == src_image->height) {
>-	/* same for x and y, just send it out */
>-	XPutImage(display, d, gc, src_image, exp_x, exp_y, 
>-		  exp_x, exp_y, exp_width, exp_height); 
>-	return;
>-    }
>-
>-    ratio_x = (double)dest_width / (double)src_image->width;
>-    ratio_y = (double)dest_height / (double)src_image->height;
>- 
>-    src_x = exp_x / ratio_x;
>-    if (src_x >= src_image->width)
>-	src_x = src_image->width - 1;
>-    src_y = exp_y / ratio_y;
>-    if (src_y >= src_image->height)
>-	src_y = src_image->height - 1;
>-    exp_max_y = exp_y + exp_height;
>-    src_max_x = roundint((exp_x + exp_width) / ratio_x) + 1;
>-    if (src_max_x > src_image->width)
>-	src_max_x = src_image->width;
>-
>-    strip_height = 65536 / roundint(ratio_x * src_image->bytes_per_line);
>-    if (strip_height == 0)
>-	strip_height = 1;
>-    if (strip_height > exp_height)
>-	strip_height = exp_height;
>-
>-    h = strip_height + roundint(ratio_y);
>-    dest_image = XCreateImage(display,
>-			      DefaultVisualOfScreen(
>-					     DefaultScreenOfDisplay(display)),
>-			      src_image->depth, src_image->format, 
>-			      0, NULL,
>-			      dest_width, h,
>-			      src_image->bitmap_pad, 0);
>-    dest_image->data = malloc(dest_image->bytes_per_line * h);
>-    fast8 = (src_image->depth == 8 && src_image->bits_per_pixel == 8 &&
>-	     dest_image->bits_per_pixel == 8 && src_image->format == ZPixmap);
>-
>-    table.x = (Position *) malloc(sizeof(Position) * (src_image->width + 1));
>-    table.y = (Position *) malloc(sizeof(Position) * (src_image->height + 1));
>-    table.width = (Dimension *) malloc(sizeof(Dimension) * src_image->width);
>-    table.height = (Dimension *) malloc(sizeof(Dimension)*src_image->height);
>-    
>-    table.x[0] = 0;
>-    for (x = 1; x <= src_image->width; x++) {
>-	table.x[x] = roundint(ratio_x * x);
>-	table.width[x - 1] = table.x[x] - table.x[x - 1];
>-    }
>-
>-    table.y[0] = 0;
>-    for (y = 1; y <= src_image->height; y++) {
>-	table.y[y] = roundint(ratio_y * y);
>-	table.height[y - 1] = table.y[y] - table.y[y - 1];
>-    }
>-
>-    for (min_y = table.y[src_y]; min_y < exp_max_y; min_y = table.y[y]) {
>-	max_y = min_y + strip_height;
>-	if (max_y > exp_max_y) {
>-	    strip_height = exp_max_y - min_y;
>-	    max_y = exp_max_y;
>-	}
>-	for (y = src_y; table.y[y] < max_y; y++) {
>-	    if (table.y[y] < min_y)
>-		continue;
>-	    if (fast8) {
>-		for (x = src_x; x < src_max_x; x++) {
>-		    pixel = ((unsigned char *)src_image->data)
>-			[y * src_image->bytes_per_line + x];
>-		    for (h = 0; h < table.height[y]; h++) {
>-			memset(dest_image->data +
>-			       (table.y[y] + h - min_y) *
>-			       dest_image->bytes_per_line + table.x[x],
>-			       pixel, table.width[x]);
>-		    }
>-		}
>-	    } else {
>-		for (x = src_x; x < src_max_x; x++) {
>-		    pixel = XGetPixel(src_image, x, y);
>-		    for (h = 0; h < table.height[y]; h++) {
>-			for (w = 0; w < table.width[x]; w++)
>-			    XPutPixel(dest_image,
>-				      table.x[x] + w,
>-				      table.y[y] + h - min_y,
>-				      pixel);
>-		    }
>-		}
>-	    }
>-	}
>-	XPutImage(display, d, gc, dest_image, exp_x, 0,
>-		  exp_x, min_y, exp_width, table.y[y] - min_y);
>-	if (y >= src_image->height)
>-	    break;
>-    }
>-    
>-    XFree((char *)table.x);
>-    XFree((char *)table.y);
>-    XFree((char *)table.width);
>-    XFree((char *)table.height);
>-
>-    XDestroyImage(dest_image);
>-}
>-
>-Latin1Upper(s)
>-    char *s;
>-{
>-    unsigned char *str = (unsigned char *)s;
>-    unsigned char c;
>-
>-    for (; (c = *str); str++)
>-    {
>-	if ((c >= XK_a) && (c <= XK_z))
>-	    *str = c - (XK_a - XK_A);
>-	else if ((c >= XK_agrave) && (c <= XK_odiaeresis))
>-	    *str = c - (XK_agrave - XK_Agrave);
>-	else if ((c >= XK_oslash) && (c <= XK_thorn))
>-	    *str = c - (XK_oslash - XK_Ooblique);
>-    }
>-}
>-
>-Extract_Plane(in_image, out_image, plane)
>-    register XImage *in_image, *out_image;
>-    int plane;
>-{
>-    register int x, y;
>-
>-    for (y = 0; y < in_image->height; y++)
>-	for (x = 0; x < in_image->width; x++)
>-	    XPutPixel(out_image, x, y,
>-		      (XGetPixel(in_image, x, y) >> plane) & 1);
>-}
>-
>-int
>-EffectiveSize(vinfo)
>-    XVisualInfo *vinfo;
>-{
>-    if ((vinfo->class == DirectColor) || (vinfo->class == TrueColor))
>-	return (vinfo->red_mask | vinfo->green_mask | vinfo->blue_mask) + 1;
>-    else
>-	return vinfo->colormap_size;
>-}
>-
>-VisualRank(class)
>-    int class;
>-{
>-    switch (class) {
>-    case PseudoColor:
>-	return 5;
>-    case DirectColor:
>-	return 4;
>-    case TrueColor:
>-	return 3;
>-    case StaticColor:
>-	return 2;
>-    case GrayScale:
>-	return 1;
>-    case StaticGray:
>-	return 0;
>-    }
>-}
>-
>-int
>-IsGray(dpy, stdmap)
>-    Display *dpy;
>-    XStandardColormap *stdmap;
>-{
>-    XColor color;
>-
>-    color.pixel = stdmap->base_pixel + (stdmap->red_max * stdmap->red_mult);
>-    XQueryColor(dpy, stdmap->colormap, &color);
>-    return (color.green || color.blue);
>-}
>-
>-Do_StdGray(dpy, stdmap, ncolors, colors, in_image, out_image)
>-    Display *dpy;
>-    XStandardColormap *stdmap;
>-    int ncolors;
>-    XColor *colors;
>-    register XImage *in_image, *out_image;
>-{
>-    register int i, x, y;
>-    register XColor *color;
>-    unsigned lim;
>-
>-    lim = stdmap->red_max + 1;
>-    for (i = 0, color = colors; i < ncolors; i++, color++)
>-	color->pixel = stdmap->base_pixel +
>-		       (((((int)(30L * color->red +
>-			         59L * color->green +
>-			         11L * color->blue) / 100)
>-			  * lim) >> 16) * stdmap->red_mult);
>-    for (y = 0; y < in_image->height; y++) {
>-	for (x = 0; x < in_image->width; x++) {
>-	    XPutPixel(out_image, x, y,
>-		      colors[XGetPixel(in_image, x, y)].pixel);
>-	}
>-    }
>-}
>-
>-#define MapVal(val,lim,mult) ((((val * lim) + 32768) / 65535) * mult)
>-
>-Do_StdCol(dpy, stdmap, ncolors, colors, in_image, out_image)
>-    Display *dpy;
>-    XStandardColormap *stdmap;
>-    int ncolors;
>-    XColor *colors;
>-    register XImage *in_image, *out_image;
>-{
>-    register int i, x, y;
>-    register XColor *color;
>-    unsigned limr, limg, limb;
>-
>-    limr = stdmap->red_max;
>-    limg = stdmap->green_max;
>-    limb = stdmap->blue_max;
>-    for (i = 0, color = colors; i < ncolors; i++, color++)
>-	color->pixel = stdmap->base_pixel +
>-		       MapVal(color->red, limr, stdmap->red_mult) +
>-		       MapVal(color->green, limg, stdmap->green_mult) +
>-		       MapVal(color->blue, limb, stdmap->blue_mult);
>-    for (y = 0; y < in_image->height; y++) {
>-	for (x = 0; x < in_image->width; x++) {
>-	    XPutPixel(out_image, x, y,
>-		      colors[XGetPixel(in_image, x, y)].pixel);
>-	}
>-    }
>-}
>-
>-Colormap
>-CopyColormapAndFree(dpy, colormap)
>-    Display *dpy;
>-    Colormap colormap;
>-{
>-    if (colormap == DefaultColormap(dpy, DefaultScreen(dpy)))
>-	return XCopyColormapAndFree(dpy, colormap);
>-    Error("Visual type is not large enough to hold all colors of the image.");
>-}
>-
>-Do_Pseudo(dpy, colormap, ncolors, colors, in_image, out_image)
>-    Display *dpy;
>-    Colormap *colormap;
>-    int ncolors;
>-    XColor *colors;
>-    register XImage *in_image, *out_image;
>-{
>-    register int i, x, y;
>-    register XColor *color;
>-
>-    for (i = 0; i < ncolors; i++)
>-	colors[i].flags = 0;
>-    for (y = 0; y < in_image->height; y++) {
>-	for (x = 0; x < in_image->width; x++) {
>-	    color = &colors[XGetPixel(in_image, x, y)];
>-	    if (!color->flags) {
>-		color->flags = DoRed | DoGreen | DoBlue;
>-		if (!XAllocColor(dpy, *colormap, color)) {
>-		    *colormap = CopyColormapAndFree(dpy, *colormap);
>-		    XAllocColor(dpy, *colormap, color);
>-		}
>-	    }
>-	    XPutPixel(out_image, x, y, color->pixel);
>-	}
>-    }
>-}
>-
>-Do_Direct(dpy, header, colormap, ncolors, colors, in_image, out_image)
>-    Display *dpy;
>-    XWDFileHeader *header;
>-    Colormap *colormap;
>-    int ncolors;
>-    XColor *colors;
>-    XImage *in_image, *out_image;
>-{
>-    register int x, y;
>-    XColor color;
>-    unsigned long rmask, gmask, bmask;
>-    int rshift = 0, gshift = 0, bshift = 0;
>-    int i;
>-    unsigned long pix, xpix;
>-    unsigned long *pixels, *rpixels;
>-
>-    rmask = header->red_mask;
>-    while (!(rmask & 1)) {
>-	rmask >>= 1;
>-	rshift++;
>-    }
>-    gmask = header->green_mask;
>-    while (!(gmask & 1)) {
>-	gmask >>= 1;
>-	gshift++;
>-    }
>-    bmask = header->blue_mask;
>-    while (!(bmask & 1)) {
>-	bmask >>= 1;
>-	bshift++;
>-    }
>-    if (in_image->depth <= 12) {
>-	pix = 1 << in_image->depth;
>-	pixels = (unsigned long *)malloc(sizeof(unsigned long) * pix);
>-	for (i = 0; i < pix; i++)
>-	    pixels[i] = ~0L;
>-	color.flags = DoRed | DoGreen | DoBlue;
>-	for (y = 0; y < in_image->height; y++) {
>-	    for (x = 0; x < in_image->width; x++) {
>-		pix = XGetPixel(in_image, x, y);
>-		if ((color.pixel = pixels[pix]) == ~0L) {
>-		    color.red = (pix >> rshift) & rmask;
>-		    color.green = (pix >> gshift) & gmask;
>-		    color.blue = (pix >> bshift) & bmask;
>-		    if (ncolors) {
>-			color.red = colors[color.red].red;
>-			color.green = colors[color.green].green;
>-			color.blue = colors[color.blue].blue;
>-		    } else {
>-			color.red = (((unsigned long)color.red * 65535) /
>-				     rmask);
>-			color.green = (((unsigned long)color.green * 65535) /
>-				       gmask);
>-			color.blue = (((unsigned long)color.blue * 65535) /
>-				      bmask);
>-		    }
>-		    if (!XAllocColor(dpy, *colormap, &color)) {
>-			*colormap = CopyColormapAndFree(dpy, *colormap);
>-			XAllocColor(dpy, *colormap, &color);
>-		    }
>-		    pixels[pix] = color.pixel;
>-		}
>-		XPutPixel(out_image, x, y, color.pixel);
>-	    }
>-	}
>-    } else {
>-	pix = 1 << 12;
>-	pixels = (unsigned long *)malloc(sizeof(unsigned long) * pix);
>-	rpixels = (unsigned long *)malloc(sizeof(unsigned long) * pix);
>-	for (i = 0; i < pix; i++) {
>-	    pixels[i] = ~0L;
>-	    rpixels[i] = ~0L;
>-	}
>-	color.flags = DoRed | DoGreen | DoBlue;
>-	for (y = 0; y < in_image->height; y++) {
>-	    for (x = 0; x < in_image->width; x++) {
>-		pix = XGetPixel(in_image, x, y);
>-		xpix = ((pix >> 12) ^ pix) & ((1 << 12) - 1);
>-		if (((color.pixel = pixels[xpix]) == ~0L) ||
>-		    (rpixels[xpix] != pix)) {
>-		    color.red = (pix >> rshift) & rmask;
>-		    color.green = (pix >> gshift) & gmask;
>-		    color.blue = (pix >> bshift) & bmask;
>-		    if (ncolors) {
>-			color.red = colors[color.red].red;
>-			color.green = colors[color.green].green;
>-			color.blue = colors[color.blue].blue;
>-		    } else {
>-			color.red = (((unsigned long)color.red * 65535) /
>-				     rmask);
>-			color.green = (((unsigned long)color.green * 65535) /
>-				       gmask);
>-			color.blue = (((unsigned long)color.blue * 65535) /
>-				      bmask);
>-		    }
>-		    if (!XAllocColor(dpy, *colormap, &color)) {
>-			*colormap = CopyColormapAndFree(dpy, *colormap);
>-			XAllocColor(dpy, *colormap, &color);
>-		    }
>-		    pixels[xpix] = color.pixel;
>-		    rpixels[xpix] = pix;
>-		}
>-		XPutPixel(out_image, x, y, color.pixel);
>-	    }
>-	}
>-    }
>-}
>-
>-unsigned Image_Size(image)
>-     XImage *image;
>-{
>-    if (image->format != ZPixmap)
>-      return(image->bytes_per_line * image->height * image->depth);
>-
>-    return((unsigned)image->bytes_per_line * image->height);
>-}
>-
>-Error(string)
>-	char *string;
>-{
>-	fprintf(stderr, "xwud: Error => %s\n", string);
>-	if (errno != 0) {
>-		perror("xwud");
>-		fprintf(stderr, "\n");
>-	}
>-	exit(1);
>-}
>-
>-_swapshort (bp, n)
>-    register char *bp;
>-    register unsigned n;
>-{
>-    register char c;
>-    register char *ep = bp + n;
>-
>-    while (bp < ep) {
>-	c = *bp;
>-	*bp = *(bp + 1);
>-	bp++;
>-	*bp++ = c;
>-    }
>-}
>-
>-_swaplong (bp, n)
>-    register char *bp;
>-    register unsigned n;
>-{
>-    register char c;
>-    register char *ep = bp + n;
>-    register char *sp;
>-
>-    while (bp < ep) {
>-	sp = bp + 3;
>-	c = *sp;
>-	*sp = *bp;
>-	*bp++ = c;
>-	sp = bp + 1;
>-	c = *sp;
>-	*sp = *bp;
>-	*bp++ = c;
>-	bp += 2;
>-    }
>-}
>Index: xc/programs/xwud/xwud.man
>===================================================================
>RCS file: xc/programs/xwud/xwud.man
>diff -N xc/programs/xwud/xwud.man
>--- xc/programs/xwud/xwud.man	28 May 2002 01:50:59 -0000	1.1.1.1
>+++ /dev/null	1 Jan 1970 00:00:00 -0000
>@@ -1,150 +0,0 @@
>-.\" $Xorg: xwud.man,v 1.4 2001/02/09 02:06:04 xorgcvs Exp $
>-.\" Copyright 1988, 1998  The Open Group
>-.\" 
>-.\" Permission to use, copy, modify, distribute, and sell this software and its
>-.\" documentation for any purpose is hereby granted without fee, provided that
>-.\" the above copyright notice appear in all copies and that both that
>-.\" copyright notice and this permission notice appear in supporting
>-.\" documentation.
>-.\" 
>-.\" 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 OPEN GROUP 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 of The Open Group shall
>-.\" not be used in advertising or otherwise to promote the sale, use or
>-.\" other dealings in this Software without prior written authorization
>-.\" from The Open Group.
>-.TH XWUD 1 "Release 6.4" "X Version 11"
>-.SH NAME
>-xwud - image displayer for X
>-.SH SYNOPSIS
>-.B "xwud"
>-[-in \fIfile\fP] [-noclick] [-geometry \fIgeom\fP] [-display \fIdisplay\fP]
>-[-new] [-std <maptype>] [-raw] [-vis <vis-type-or-id>] [-scale]
>-[-help] [-rv] [-plane \fInumber\fP] [-fg \fIcolor\fP] [-bg \fIcolor\fP]
>-.SH DESCRIPTION
>-.PP
>-.I Xwud
>-is an X Window System image undumping utility.
>-.I Xwud
>-allows X users to display in a window an image saved
>-in a specially formatted dump file, such as produced by \fIxwd(1)\fP.
>-.SH OPTIONS
>-.PP
>-.TP 8
>-.B "-bg \fIcolor\fP"
>-If a bitmap image (or a single plane of an image) is displayed, this option
>-can be used to specify the color to display for the "0" bits in the image.
>-.PP
>-.TP 8
>-.B "-display \fIdisplay\fP"
>-This option allows you to specify the server to connect to; see \fIX(1)\fP.
>-.PP
>-.TP 8
>-.B "-fg \fIcolor\fP"
>-If a bitmap image (or a single plane of an image) is displayed, this option
>-can be used to specify the color to display for the "1" bits in the image.
>-.PP
>-.TP 8
>-.B "-geometry \fIgeom\fP"
>-This option allows you to specify the size and position of the window.
>-Typically you will only want to specify the position, and let the size
>-default to the actual size of the image.
>-.PP
>-.TP 8
>-.B "-help"
>-Print out a short description of the allowable options.
>-.PP
>-.TP 8
>-.B "-in \fIfile\fP"
>-This option allows the user to explicitly specify the input 
>-file on the command line.  If no input file is given, the standard input
>-is assumed.
>-.PP
>-.TP 8
>-.B -new
>-This option forces creation of a new colormap for displaying the image.
>-If the image characteristics happen to match those of the display, this
>-can get the image on the screen faster, but at the cost of using a new
>-colormap (which on most displays will cause other windows to go
>-technicolor).
>-.PP
>-.TP 8
>-.B "-noclick"
>-Clicking any button in the window will terminate the application,
>-unless this option is specified.  Termination can always be achieved
>-by typing 'q', 'Q', or ctrl-c.
>-.PP
>-.TP 8
>-.B "-plane \fInumber\fP"
>-You can select a single bit plane of the image to display
>-with this option.  Planes are numbered with zero being the least
>-significant bit.  This option can be used to figure out which plane to
>-pass to \fIxpr(1)\fP for printing.
>-.PP
>-.TP 8
>-.B -raw
>-This option forces the image to be displayed with whatever color values
>-happen to currently exist on the screen.  This option is mostly useful when
>-undumping an image back onto the same screen that the image originally
>-came from, while the original windows are still on the screen, and results
>-in getting the image on the screen faster.
>-.PP
>-.TP 8
>-.B -rv
>-If a bitmap image (or a single plane of an image) is displayed, this option
>-forces the foreground and background colors to be swapped.  This may be
>-needed when displaying a bitmap image which has the color sense of pixel
>-values "0" and "1" reversed from what they are on your display.
>-.PP
>-.TP 8
>-.B -scale
>-Allow the window to be resized, and scale the image to the size of the window.
>-.PP
>-.TP 8
>-.B "-std \fImaptype\fP"
>-This option causes the image to be displayed using the specified
>-Standard Colormap.  The property name is obtained by converting the
>-type to upper case, prepending "RGB_", and appending "_MAP".
>-Typical types are "best", "default", and "gray".  See \fIxstdcmap(1)\fP
>-for one way of creating Standard Colormaps.
>-.PP
>-.TP 8
>-.B "-vis \fIvis-type-or-id\fP"
>-This option allows you to specify a particular visual or visual class.
>-The default is to pick the "best" one.  A particular class can be
>-specified: "StaticGray", "GrayScale", "StaticColor", "PseudoColor",
>-"DirectColor", or "TrueColor".  Or "Match" can be specified, meaning
>-use the same class as the source image.  Alternatively, an exact
>-visual id (specific to the server) can be specified, either as a
>-hexadecimal number (prefixed with "0x") or as a decimal number.
>-Finally, "default" can be specified, meaning to use the same class
>-as the colormap of the root window.  Case is not significant in
>-any of these strings.
>-.SH ENVIRONMENT
>-.PP
>-.TP 8
>-.B DISPLAY
>-To get default display.
>-.SH FILES
>-.PP
>-.TP 8
>-.B XWDFile.h
>-X Window Dump File format definition file.
>-.SH BUGS
>-xwud doesn't handle big/deep images very well on servers that don't 
>-have the BIG-REQUESTS extension.
>-.SH SEE ALSO
>-xwd(1), xpr(1), xstdcmap(1), X(1)
>-.SH AUTHOR
>-Bob Scheifler, MIT X Consortium
>-
>-

Actions: View | Splinter Review

Attachments on bug 799: 413

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.